C++ nsTArray::SwapElements方法代码示例

void
LayerManager::StopFrameTimeRecording(nsTArray<float>& aTimes)
{
  mLastFrameTime = TimeStamp();
  aTimes.SwapElements(mFrameTimes);
  mFrameTimes.Clear();
}

/* static */ void
nsBrowserElement::GenerateAllowedAudioChannels(
                 nsPIDOMWindowInner* aWindow,
                 nsIFrameLoader* aFrameLoader,
                 nsIBrowserElementAPI* aAPI,
                 nsTArray<RefPtr<BrowserElementAudioChannel>>& aAudioChannels,
                 ErrorResult& aRv)
{
  MOZ_ASSERT(aAudioChannels.IsEmpty());

  // Normal is always allowed.
  nsTArray<RefPtr<BrowserElementAudioChannel>> channels;

  RefPtr<BrowserElementAudioChannel> ac =
    BrowserElementAudioChannel::Create(aWindow, aFrameLoader, aAPI,
                                       AudioChannel::Normal, aRv);
  if (NS_WARN_IF(aRv.Failed())) {
    return;
  }

  channels.AppendElement(ac);

  nsCOMPtr<nsIDocument> doc = aWindow->GetExtantDoc();
  if (NS_WARN_IF(!doc)) {
    aRv.Throw(NS_ERROR_FAILURE);
    return;
  }

  // Since we don't have permissions anymore let only chrome windows pick a
  // non-default channel
  if (nsContentUtils::IsChromeDoc(doc)) {
    const nsAttrValue::EnumTable* audioChannelTable =
      AudioChannelService::GetAudioChannelTable();

    for (uint32_t i = 0; audioChannelTable && audioChannelTable[i].tag; ++i) {
      AudioChannel value = (AudioChannel)audioChannelTable[i].value;
      RefPtr<BrowserElementAudioChannel> ac =
        BrowserElementAudioChannel::Create(aWindow, aFrameLoader, aAPI,
                                           value, aRv);
      if (NS_WARN_IF(aRv.Failed())) {
        return;
      }

      channels.AppendElement(ac);
    }
  }

  aAudioChannels.SwapElements(channels);
}

nsresult
FragmentBuffer::GetFirstFragment(nsTArray<nsRefPtr<EncodedFrame>>& aFragment,
                                 bool aFlush)
{
  // It should be called only if there is a complete fragment in mFragArray.
  if (mFragArray.Length() <= 1 && !mEOS) {
    MOZ_ASSERT(false);
    return NS_ERROR_FAILURE;
  }

  if (aFlush) {
    aFragment.SwapElements(mFragArray.ElementAt(0));
    mFragArray.RemoveElementAt(0);
  } else {
    aFragment.AppendElements(mFragArray.ElementAt(0));
  }
  return NS_OK;
}

static inline nsresult WebCL_variantToInternalVector3 (JSContext* cx, nsIVariant* aVariant,
                                                       nsTArray<size_t>& aRegionOut)
{
  D_METHOD_START;
  NS_ENSURE_ARG_POINTER (cx);
  NS_ENSURE_ARG_POINTER (aVariant);
  nsresult rv;

  nsTArray<nsIVariant*> variants;
  rv = WebCL_getVariantsFromJSArray (cx, aVariant, variants);
  NS_ENSURE_SUCCESS (rv, rv);
  if (variants.Length () != 3)
  {
    D_LOG (LOG_LEVEL_ERROR, "Variant array has %d items instead of exactly 3.",
           variants.Length());
    return NS_ERROR_FAILURE;
  }

  nsTArray<size_t> result;
  result.SetCapacity (3);
  for (nsTArray<nsIVariant*>::index_type i = 0; i < variants.Length(); ++i)
  {
    PRInt32 val;
    rv = variants[i]->GetAsInt32 (&val);
    if (NS_FAILED (rv)) {
      D_LOG (LOG_LEVEL_ERROR, "Variant array index %d can not be converted to integer.",
             i);
      break;
    }
    result.AppendElement ((size_t)val);
  }
  WebCL_releaseVariantVector (variants);
  NS_ENSURE_SUCCESS (rv, rv);

  aRegionOut.SwapElements (result);
  return NS_OK;
}

void
DOMIntersectionObserver::TakeRecords(nsTArray<RefPtr<DOMIntersectionObserverEntry>>& aRetVal)
{
    aRetVal.SwapElements(mQueuedEntries);
    mQueuedEntries.Clear();
}

/* static */ void
nsBrowserElement::GenerateAllowedAudioChannels(
                 nsPIDOMWindowInner* aWindow,
                 nsIFrameLoader* aFrameLoader,
                 nsIBrowserElementAPI* aAPI,
                 const nsAString& aManifestURL,
                 mozIApplication* aParentApp,
                 nsTArray<RefPtr<BrowserElementAudioChannel>>& aAudioChannels,
                 ErrorResult& aRv)
{
  MOZ_ASSERT(aAudioChannels.IsEmpty());

  nsCOMPtr<nsIAppsService> appsService =
    do_GetService("@mozilla.org/AppsService;1");
  if (NS_WARN_IF(!appsService)) {
    aRv.Throw(NS_ERROR_FAILURE);
    return;
  }

  nsCOMPtr<mozIApplication> app;
  aRv = appsService->GetAppByManifestURL(aManifestURL, getter_AddRefs(app));
  if (NS_WARN_IF(aRv.Failed())) {
    return;
  }

  // Normal is always allowed.
  nsTArray<RefPtr<BrowserElementAudioChannel>> channels;

  RefPtr<BrowserElementAudioChannel> ac =
    BrowserElementAudioChannel::Create(aWindow, aFrameLoader, aAPI,
                                       AudioChannel::Normal,
                                       aManifestURL, aRv);
  if (NS_WARN_IF(aRv.Failed())) {
    return;
  }

  channels.AppendElement(ac);

  if (app) {
    const nsAttrValue::EnumTable* audioChannelTable =
      AudioChannelService::GetAudioChannelTable();

    bool allowed;
    nsAutoCString permissionName;

    for (uint32_t i = 0; audioChannelTable && audioChannelTable[i].tag; ++i) {
      permissionName.AssignASCII("audio-channel-");
      permissionName.AppendASCII(audioChannelTable[i].tag);

      // In case of nested iframes we want to check if the parent has the
      // permission to use this AudioChannel.
      if (aParentApp) {
        aRv = aParentApp->HasPermission(permissionName.get(), &allowed);
        if (NS_WARN_IF(aRv.Failed())) {
          return;
        }

        if (!allowed) {
          continue;
        }
      }

      aRv = app->HasPermission(permissionName.get(), &allowed);
      if (NS_WARN_IF(aRv.Failed())) {
        return;
      }

      if (allowed) {
        RefPtr<BrowserElementAudioChannel> ac =
          BrowserElementAudioChannel::Create(aWindow, aFrameLoader, aAPI,
                                             (AudioChannel)audioChannelTable[i].value,
                                             aManifestURL, aRv);
        if (NS_WARN_IF(aRv.Failed())) {
          return;
        }

        channels.AppendElement(ac);
      }
    }
  }

  aAudioChannels.SwapElements(channels);
}

/* static */ bool
FeaturePolicyParser::ParseString(const nsAString& aPolicy,
                                 nsIDocument* aDocument,
                                 const nsAString& aSelfOrigin,
                                 const nsAString& aSrcOrigin,
                                 bool aSrcEnabled,
                                 nsTArray<Feature>& aParsedFeatures)
{
  nsTArray<nsTArray<nsString>> tokens;
  PolicyTokenizer::tokenizePolicy(aPolicy, tokens);

  nsTArray<Feature> parsedFeatures;

  for (const nsTArray<nsString>& featureTokens : tokens) {
    if (featureTokens.IsEmpty()) {
      continue;
    }

    if (!FeaturePolicyUtils::IsSupportedFeature(featureTokens[0])) {
      ReportToConsoleUnsupportedFeature(aDocument, featureTokens[0]);
      continue;
    }

    Feature feature(featureTokens[0]);

    if (featureTokens.Length() == 1) {
      if (aSrcEnabled) {
        // Note that this src origin can be empty if opaque.
        feature.AppendOriginToWhiteList(aSrcOrigin);
      } else {
        ReportToConsoleInvalidEmptyAllowValue(aDocument, featureTokens[0]);
        continue;
      }
    } else {
      // we gotta start at 1 here
      for (uint32_t i = 1; i < featureTokens.Length(); ++i) {
        const nsString& curVal = featureTokens[i];
        if (curVal.LowerCaseEqualsASCII("'none'")) {
          feature.SetAllowsNone();
          break;
        }

        if (curVal.EqualsLiteral("*")) {
          feature.SetAllowsAll();
          break;
        }

        if (curVal.LowerCaseEqualsASCII("'self'")) {
          // Opaque origins are passed as empty string.
          if (!aSelfOrigin.IsEmpty()) {
            feature.AppendOriginToWhiteList(aSelfOrigin);
          }
          continue;
        }

        if (aSrcEnabled && curVal.LowerCaseEqualsASCII("'src'")) {
          // Opaque origins are passed as empty string.
          if (!aSrcOrigin.IsEmpty()) {
            feature.AppendOriginToWhiteList(aSrcOrigin);
          }
          continue;
        }

        nsCOMPtr<nsIURI> uri;
        nsresult rv = NS_NewURI(getter_AddRefs(uri), curVal);
        if (NS_FAILED(rv)) {
          ReportToConsoleInvalidAllowValue(aDocument, curVal);
          continue;
        }

        nsAutoString origin;
        rv = nsContentUtils::GetUTFOrigin(uri, origin);
        if (NS_WARN_IF(NS_FAILED(rv))) {
          ReportToConsoleInvalidAllowValue(aDocument, curVal);
          continue;
        }

        feature.AppendOriginToWhiteList(origin);
      }
    }

    // No duplicate!
    bool found = false;
    for (const Feature& parsedFeature : parsedFeatures) {
      if (parsedFeature.Name() == feature.Name()) {
        found = true;
        break;
      }
    }

    if (!found) {
      parsedFeatures.AppendElement(feature);
    }
  }

  aParsedFeatures.SwapElements(parsedFeatures);
  return true;
}

void
PerformanceObserver::TakeRecords(nsTArray<RefPtr<PerformanceEntry>>& aRetval)
{
  MOZ_ASSERT(aRetval.IsEmpty());
  aRetval.SwapElements(mQueuedEntries);
}

//.........这里部分代码省略.........
  rv = aVariant->GetDataType (&variantType);
  switch (variantType)
  {
    // Accept VTYPE_ARRAY, VTYPE_EMPTY_ARRAY
    case nsIDataType::VTYPE_ARRAY:
    case nsIDataType::VTYPE_EMPTY_ARRAY:
      // Array detected
      break;
    case nsIDataType::VTYPE_INTERFACE:
    case nsIDataType::VTYPE_INTERFACE_IS:
      // Might be a proxy object holding the array
      break;

    default:
      D_LOG (LOG_LEVEL_ERROR, "Argument aVariant is not an array (type: %u).", variantType);
      return NS_ERROR_INVALID_ARG;
  }

  if (!cx)
  {
    nsCOMPtr<nsIThreadJSContextStack> stack = do_GetService ("@mozilla.org/js/xpc/ContextStack;1", &rv);
    NS_ENSURE_SUCCESS (rv, rv);
    cx = stack->GetSafeJSContext ();
    NS_ENSURE_TRUE (cx, NS_ERROR_FAILURE);
  }
  nsCOMPtr<nsIXPConnect> xpc = do_GetService (nsIXPConnect::GetCID (), &rv);
  NS_ENSURE_SUCCESS (rv, rv);

  js::Value jsVal;
  rv = xpc->VariantToJS(cx, JS_GetGlobalObject(cx), aVariant, &jsVal);
  NS_ENSURE_SUCCESS (rv, rv);

  if ( !jsVal.isObject ())
  {
    D_LOG (LOG_LEVEL_ERROR, "Argument aVariant is not a JSObject.");
    return NS_ERROR_INVALID_ARG;
  }

  JSObject* jsArrObj = jsVal.toObjectOrNull ();
  if (jsArrObj && js::IsObjectProxy (jsArrObj))
  {
    jsArrObj = js::UnwrapObject (jsArrObj);
  }

  if (!jsArrObj || !JS_IsArrayObject (cx, jsArrObj))
  {
    D_LOG (LOG_LEVEL_ERROR, "Argument aVariant is not a JS Array Object.");
    return NS_ERROR_INVALID_ARG;
  }

  nsTArray <nsIVariant*> res;

  JS_BeginRequest (cx);

  JSBool ok = JS_TRUE;
  uint32_t jsArrLen = 0;
  ok = JS_GetArrayLength(cx, jsArrObj, &jsArrLen);
  if (!ok)
  {
    JS_EndRequest(cx);
    D_LOG (LOG_LEVEL_ERROR, "Failed to get array length.");
    return NS_ERROR_FAILURE;
  }

  res.SetCapacity (jsArrLen);

  for (uint32_t i = 0; i < jsArrLen; ++i)
  {
    jsval elem;
    JSBool ok = JS_GetElement (cx, jsArrObj, i, &elem);
    if (ok)
    {
      nsCOMPtr<nsIVariant> variant;
      rv = xpc->JSValToVariant (cx, &elem, getter_AddRefs(variant));
      if (NS_SUCCEEDED (rv))
      {
        res.AppendElement (variant);
        NS_ADDREF (variant);
      }
      else
      {
        D_LOG (LOG_LEVEL_WARNING,
              "Failed to convert element at position %d to nsIVariant. (rv %d)",
              i+1, rv);
      }
    }
    else
    {
        D_LOG (LOG_LEVEL_WARNING,
               "Failed to get element at position %d to nsIVariant. (rv %d)",
               i+1, rv);
    }
  }

  JS_EndRequest(cx);

  aResultOut.SwapElements (res);

  return NS_OK;
}