// ----------------------------------------------------------------------------- // TSIPSecDigestCtxSetup::RequestUserCredentialsL // ----------------------------------------------------------------------------- // TBool TSIPSecDigestCtxSetup::RequestUserCredentialsL() { TSIPSecPluginCtxResponse& parent = static_cast<TSIPSecPluginCtxResponse&>( Parent() ); CSIPSecDigestObserver* observer = parent.Cache().RegisterObserverL( parent.Observer(), UserData() ); return UserData().RequestL( *this, *observer ); }
void WebConnection::postMessage(const String& messageName, API::Object* messageBody) { if (!hasValidConnection()) return; send(Messages::WebConnection::HandleMessage(messageName, UserData(transformObjectsToHandles(messageBody)))); }
void Simulation::generateStaticPinField(){ for(int i=0;i<this->pinBodies.size();i++){ if(pinBodies[i]){ world.DestroyBody(pinBodies[i]); } } std::vector<b2Vec2> pins(PIN_COUNT); this->pinBodies = std::vector<b2Body*>(PIN_COUNT); this->pinData = std::vector<UserData>(PIN_COUNT); b2BodyDef pinDef; pinDef.type = b2_staticBody; b2CircleShape pinSphere; pinSphere.m_p.Set(0.0f, 0.0f); pinSphere.m_radius = PIN_RADIUS; b2FixtureDef pinFixtureDef; pinFixtureDef.shape = &pinSphere; pinFixtureDef.density = PIN_DENSITY; pinFixtureDef.friction = PIN_FRICTION; pinFixtureDef.restitution = PIN_RESTITUTION; for(int i=0;i<staticPlayingField.size();i++){ pinDef.position.Set(staticPlayingField[i].x, staticPlayingField[i].y); this->pinBodies[i] = world.CreateBody(&pinDef); this->pinData[i] = UserData(UserData::PINBALL_PIN, 1.0f, true, 0, 0, 0); this->pinBodies[i]->SetUserData(&this->pinData[i]); this->pinBodies[i]->CreateFixture(&pinFixtureDef); } }
void DataKeeper::DoSaveUsers() { ModesExts currdata; const user_hash& users = ServerInstance->Users.GetUsers(); for (user_hash::const_iterator i = users.begin(); i != users.end(); ++i) { User* const user = i->second; // Serialize user modes for (size_t j = 0; j < handledmodes[MODETYPE_USER].size(); j++) { ModeHandler* mh = handledmodes[MODETYPE_USER][j].mh; if (user->IsModeSet(mh)) currdata.modelist.push_back(InstanceData(j, mh->GetUserParameter(user))); } // Serialize all extensions attached to the User SaveExtensions(user, currdata.extlist); // Save serializer name if applicable and get an index to it size_t serializerindex = SaveSerializer(user); // Add to list if the user has any modes or extensions set that we are interested in, otherwise we don't // have to do anything with this user when restoring if ((!currdata.empty()) || (serializerindex != UserData::UNUSED_INDEX)) { userdatalist.push_back(UserData(user, serializerindex)); userdatalist.back().swap(currdata); } } }
GMPErr GetRecordNames(nsTArray<nsCString>& aOutRecordNames) const override { for (auto iter = mRecords.ConstIter(); !iter.Done(); iter.Next()) { aOutRecordNames.AppendElement(iter.UserData()->mRecordName); } return GMPNoErr; }
void HTMLPropertiesCollection::EnsureFresh() { if (mDoc && !mIsDirty) { return; } mIsDirty = false; mProperties.Clear(); mNames->Clear(); // We don't clear NamedItemEntries because the PropertyNodeLists must be live. for (auto iter = mNamedItemEntries.Iter(); !iter.Done(); iter.Next()) { iter.UserData()->SetDirty(); } if (!mRoot->HasAttr(kNameSpaceID_None, nsGkAtoms::itemscope)) { return; } CrawlProperties(); TreeOrderComparator comparator; mProperties.Sort(comparator); // Create the names DOMStringList uint32_t count = mProperties.Length(); for (uint32_t i = 0; i < count; ++i) { const nsAttrValue* attr = mProperties.ElementAt(i)->GetParsedAttr(nsGkAtoms::itemprop); for (uint32_t i = 0; i < attr->GetAtomCount(); i++) { nsDependentAtomString propName(attr->AtomAt(i)); bool contains = mNames->ContainsInternal(propName); if (!contains) { mNames->Add(propName); } } } }
void WebProcessPool::postMessageToInjectedBundle(const String& messageName, API::Object* messageBody) { for (auto& process : m_processes) { // FIXME: Return early if the message body contains any references to WKPageRefs/WKFrameRefs etc. since they're local to a process. process->send(Messages::WebProcess::HandleInjectedBundleMessage(messageName, UserData(process->transformObjectsToHandles(messageBody).get())), 0); } }
void VRManager::GetVRControllerInfo(nsTArray<VRControllerInfo>& aControllerInfo) { aControllerInfo.Clear(); for (auto iter = mVRControllers.Iter(); !iter.Done(); iter.Next()) { gfx::VRControllerHost* controller = iter.UserData(); aControllerInfo.AppendElement(VRControllerInfo(controller->GetControllerInfo())); } }
/** * Get any VR displays that have already been enumerated without * activating any new devices. */ void VRManager::GetVRDisplayInfo(nsTArray<VRDisplayInfo>& aDisplayInfo) { aDisplayInfo.Clear(); for (auto iter = mVRDisplays.Iter(); !iter.Done(); iter.Next()) { gfx::VRDisplayHost* display = iter.UserData(); aDisplayInfo.AppendElement(VRDisplayInfo(display->GetDisplayInfo())); } }
void VRManager::NotifyVsync(const TimeStamp& aVsyncTimestamp) { for (auto iter = mVRDevices.Iter(); !iter.Done(); iter.Next()) { gfx::VRHMDInfo* device = iter.UserData(); device->NotifyVsync(aVsyncTimestamp); } DispatchVRDeviceSensorUpdate(); }
void Simulation::generateRandomPinField(){ std::default_random_engine generator(std::chrono::system_clock::now().time_since_epoch().count()); std::uniform_real_distribution<float> distribution_X = std::uniform_real_distribution<float>(PIN_BOUNDARY_X_MIN, PIN_BOUNDARY_X_MAX); std::uniform_real_distribution<float> distribution_Y = std::uniform_real_distribution<float>(PIN_BOUNDARY_Y_MIN, PIN_BOUNDARY_Y_MAX); int pins_generated = 0; b2Vec2 v; bool add; for(int i=0;i<this->pinBodies.size();i++){ if(pinBodies[i]){ world.DestroyBody(pinBodies[i]); } } std::vector<b2Vec2> pins(PIN_COUNT); this->pinBodies = std::vector<b2Body*>(PIN_COUNT); this->pinData = std::vector<UserData>(PIN_COUNT); b2BodyDef pinDef; pinDef.type = b2_staticBody; b2CircleShape pinSphere; pinSphere.m_p.Set(0.0f, 0.0f); pinSphere.m_radius = PIN_RADIUS; b2FixtureDef pinFixtureDef; pinFixtureDef.shape = &pinSphere; pinFixtureDef.density = PIN_DENSITY; pinFixtureDef.friction = PIN_FRICTION; pinFixtureDef.restitution = PIN_RESTITUTION; while(pins_generated < PIN_COUNT){ v = b2Vec2(distribution_X(generator), distribution_Y(generator)); add = true; for(int i=0;i<pins_generated;i++){ if((pins[i] - v).Length() <= 6 * PIN_RADIUS){ add = false; break; } } if(add){ //if it's the last one and is still valid add it pinDef.position.Set(v.x, v.y); this->pinBodies[pins_generated] = world.CreateBody(&pinDef); this->pinData[pins_generated] = UserData(UserData::PINBALL_PIN, 1.0f, true, 0, 0, 0); this->pinBodies[pins_generated]->SetUserData(&this->pinData[pins_generated]); this->pinBodies[pins_generated]->CreateFixture(&pinFixtureDef); pins_generated++; } } }
void WebChromeClient::didCancelTrackingPotentialLongMousePress() { RefPtr<API::Object> userData; // Notify the bundle client. m_page->injectedBundleUIClient().didCancelTrackingPotentialLongMousePress(m_page, userData); // Notify the UIProcess. m_page->send(Messages::WebPageProxy::DidCancelTrackingPotentialLongMousePress(UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get()))); }
~GMPDiskStorage() { // Close all open file handles. for (auto iter = mRecords.ConstIter(); !iter.Done(); iter.Next()) { Record* record = iter.UserData(); if (record->mFileDesc) { PR_Close(record->mFileDesc); record->mFileDesc = nullptr; } } }
void WebProcessPool::handleSynchronousMessage(IPC::Connection& connection, const String& messageName, const UserData& messageBody, UserData& returnUserData) { auto* webProcessProxy = WebProcessProxy::fromConnection(&connection); if (!webProcessProxy) return; RefPtr<API::Object> returnData; m_injectedBundleClient.didReceiveSynchronousMessageFromInjectedBundle(this, messageName, webProcessProxy->transformHandlesToObjects(messageBody.object()).get(), returnData); returnUserData = UserData(webProcessProxy->transformObjectsToHandles(returnData.get())); }
void WebChromeClient::handleAutoFillButtonClick(HTMLInputElement& inputElement) { RefPtr<API::Object> userData; // Notify the bundle client. auto nodeHandle = InjectedBundleNodeHandle::getOrCreate(inputElement); m_page->injectedBundleUIClient().didClickAutoFillButton(*m_page, nodeHandle.get(), userData); // Notify the UIProcess. m_page->send(Messages::WebPageProxy::HandleAutoFillButtonClick(UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get()))); }
void LoginWindow::login(){ try{ lError->setHidden(true); (new ClientWindow(new LinQedInClient(UserData(teUsername->text(),tePwd->text()))))->showMaximized(); close(); }//try catch(const NoUserException& exc){ lError->setHidden(false); lError->setText(exc.what()); }//catch }//login
void MediaEngineWebRTC::Shutdown() { // This is likely paranoia MutexAutoLock lock(mMutex); if (camera::GetCamerasChildIfExists()) { camera::GetChildAndCall( &camera::CamerasChild::RemoveDeviceChangeCallback, this); } LOG(("%s", __FUNCTION__)); // Shutdown all the sources, since we may have dangling references to the // sources in nsDOMUserMediaStreams waiting for GC/CC for (auto iter = mVideoSources.Iter(); !iter.Done(); iter.Next()) { MediaEngineVideoSource* source = iter.UserData(); if (source) { source->Shutdown(); } } for (auto iter = mAudioSources.Iter(); !iter.Done(); iter.Next()) { MediaEngineAudioSource* source = iter.UserData(); if (source) { source->Shutdown(); } } mVideoSources.Clear(); mAudioSources.Clear(); if (mVoiceEngine) { mVoiceEngine->SetTraceCallback(nullptr); webrtc::VoiceEngine::Delete(mVoiceEngine); } mVoiceEngine = nullptr; mozilla::camera::Shutdown(); AudioInputCubeb::CleanupGlobalData(); }
void VRManager::DispatchVRDeviceInfoUpdate() { nsTArray<VRDeviceUpdate> update; for (auto iter = mVRDevices.Iter(); !iter.Done(); iter.Next()) { gfx::VRHMDInfo* device = iter.UserData(); update.AppendElement(VRDeviceUpdate(device->GetDeviceInfo(), device->GetSensorState())); } for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) { Unused << iter.Get()->GetKey()->SendUpdateDeviceInfo(update); } }
NS_IMETHODIMP nsMsgGroupView::CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater) { nsMsgDBView::CopyDBView(aNewMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater); nsMsgGroupView* newMsgDBView = (nsMsgGroupView *) aNewMsgDBView; // If grouped, we need to clone the group thread hash table. if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort) { for (auto iter = m_groupsTable.Iter(); !iter.Done(); iter.Next()) { newMsgDBView->m_groupsTable.Put(iter.Key(), iter.UserData()); } } return NS_OK; }
already_AddRefed<mozIStorageError> AsyncBindingParams::bind(sqlite3_stmt * aStatement) { // We should bind by index using the super-class if there is nothing in our // hashtable. if (!mNamedParameters.Count()) return BindingParams::bind(aStatement); nsCOMPtr<mozIStorageError> err; for (auto iter = mNamedParameters.Iter(); !iter.Done(); iter.Next()) { const nsACString &key = iter.Key(); // We do not accept any forms of names other than ":name", but we need to // add the colon for SQLite. nsAutoCString name(":"); name.Append(key); int oneIdx = ::sqlite3_bind_parameter_index(aStatement, name.get()); if (oneIdx == 0) { nsAutoCString errMsg(key); errMsg.AppendLiteral(" is not a valid named parameter."); err = new Error(SQLITE_RANGE, errMsg.get()); break; } // XPCVariant's AddRef and Release are not thread-safe and so we must not // do anything that would invoke them here on the async thread. As such we // can't cram aValue into mParameters using ReplaceObjectAt so that // we can freeload off of the BindingParams::Bind implementation. int rc = variantToSQLiteT(BindingColumnData(aStatement, oneIdx - 1), iter.UserData()); if (rc != SQLITE_OK) { // We had an error while trying to bind. Now we need to create an error // object with the right message. Note that we special case // SQLITE_MISMATCH, but otherwise get the message from SQLite. const char *msg = "Could not covert nsIVariant to SQLite type."; if (rc != SQLITE_MISMATCH) { msg = ::sqlite3_errmsg(::sqlite3_db_handle(aStatement)); } err = new Error(rc, msg); break; } } return err.forget(); }
void VRManager::DispatchVRDeviceSensorUpdate() { nsTArray<VRSensorUpdate> update; for (auto iter = mVRDevices.Iter(); !iter.Done(); iter.Next()) { gfx::VRHMDInfo* device = iter.UserData(); if (!device->GetDeviceInfo().GetUseMainThreadOrientation()) { update.AppendElement(VRSensorUpdate(device->GetDeviceInfo().GetDeviceID(), device->GetSensorState())); } } if (update.Length() > 0) { for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) { Unused << iter.Get()->GetKey()->SendUpdateDeviceSensors(update); } } }
CBomb::CBomb(Ogre::SceneNode *pParentNode, CObjectManager &objectManager, const Ogre::Vector3 &vPosition) : CLiftableObject(pParentNode, objectManager, NULL, LOT_BOMB, false, UserData()), m_pListener(NULL) { m_pSceneNode = pParentNode->createChildSceneNode(); m_pSceneNode->attachObject(pParentNode->getCreator()->createEntity(BOMB_MESH)); m_pSceneNode->setScale(Ogre::Vector3::UNIT_SCALE * CPerson::PERSON_SCALE); m_fTimer = BOMB_TIMER; btCollisionShape *pShape = new btSphereShape(BOMB_COL_RADIUS); btRigidBody::btRigidBodyConstructionInfo ci(BOMB_MASS, new BtOgre::RigidBodyState(m_pSceneNode), pShape); btRigidBody *pRB = new btRigidBody(ci); objectManager.getMap().getPhysicsManager()->getWorld()->addRigidBody(pRB, COL_INTERACTIVE, MASK_STATIC_COLLIDES_WITH | COL_STATIC); m_pCollisionObject = pRB; setAsUserPointer(m_pCollisionObject); pRB->getWorldTransform().setOrigin(BtOgre::Convert::toBullet(vPosition + Ogre::Vector3::UNIT_Y * BOMB_COL_RADIUS)); }
NS_IMETHODIMP nsFontFaceList::Item(uint32_t index, nsIDOMFontFace **_retval) { NS_ENSURE_TRUE(index < mFontFaces.Count(), NS_ERROR_INVALID_ARG); uint32_t current = 0; nsIDOMFontFace* result = nullptr; for (auto iter = mFontFaces.Iter(); !iter.Done(); iter.Next()) { if (current == index) { result = iter.UserData(); break; } current++; } NS_ASSERTION(result != nullptr, "null entry in nsFontFaceList?"); NS_IF_ADDREF(*_retval = result); return NS_OK; }
void VRManager::NotifyVsync(const TimeStamp& aVsyncTimestamp) { const double kVRDisplayRefreshMaxDuration = 5000; // milliseconds bool bHaveEventListener = false; for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) { VRManagerParent *vmp = iter.Get()->GetKey(); if (mVRDisplays.Count()) { Unused << vmp->SendNotifyVSync(); } bHaveEventListener |= vmp->HaveEventListener(); } for (auto iter = mVRDisplays.Iter(); !iter.Done(); iter.Next()) { gfx::VRDisplayHost* display = iter.UserData(); display->NotifyVSync(); } if (bHaveEventListener) { // If content has set an EventHandler to be notified of VR display events // we must continually refresh the VR display enumeration to check // for events that we must fire such as Window.onvrdisplayconnect // Note that enumeration itself may activate display hardware, such // as Oculus, so we only do this when we know we are displaying content // that is looking for VR displays. if (mLastRefreshTime.IsNull()) { // This is the first vsync, must refresh VR displays RefreshVRDisplays(); RefreshVRControllers(); mLastRefreshTime = TimeStamp::Now(); } else { // We don't have to do this every frame, so check if we // have refreshed recently. TimeDuration duration = TimeStamp::Now() - mLastRefreshTime; if (duration.ToMilliseconds() > kVRDisplayRefreshMaxDuration) { RefreshVRDisplays(); RefreshVRControllers(); mLastRefreshTime = TimeStamp::Now(); } } } }
NS_IMETHODIMP nsGTKRemoteService::Startup(const char* aAppName, const char* aProfileName) { NS_ASSERTION(aAppName, "Don't pass a null appname!"); sRemoteImplementation = this; if (mServerWindow) return NS_ERROR_ALREADY_INITIALIZED; XRemoteBaseStartup(aAppName, aProfileName); mServerWindow = gtk_invisible_new(); gtk_widget_realize(mServerWindow); HandleCommandsFor(mServerWindow, nullptr); for (auto iter = mWindows.Iter(); !iter.Done(); iter.Next()) { HandleCommandsFor(iter.Key(), iter.UserData()); } return NS_OK; }
bool DOMStorageDBThread::PendingOperations::IsOriginUpdatePending(const nsACString& aOriginSuffix, const nsACString& aOriginNoSuffix) const { // Called under the lock for (auto iter = mUpdates.ConstIter(); !iter.Done(); iter.Next()) { if (FindPendingUpdateForOrigin(aOriginSuffix, aOriginNoSuffix, iter.UserData())) { return true; } } for (uint32_t i = 0; i < mExecList.Length(); ++i) { if (FindPendingUpdateForOrigin(aOriginSuffix, aOriginNoSuffix, mExecList[i])) { return true; } } return false; }
void WebRenderBridgeParent::SampleAnimations(nsTArray<wr::WrOpacityProperty>& aOpacityArray, nsTArray<wr::WrTransformProperty>& aTransformArray) { AdvanceAnimations(); // return the animated data if has if (mAnimStorage->AnimatedValueCount()) { for(auto iter = mAnimStorage->ConstAnimatedValueTableIter(); !iter.Done(); iter.Next()) { AnimatedValue * value = iter.UserData(); if (value->mType == AnimatedValue::TRANSFORM) { aTransformArray.AppendElement( wr::ToWrTransformProperty(iter.Key(), value->mTransform.mTransformInDevSpace)); } else if (value->mType == AnimatedValue::OPACITY) { aOpacityArray.AppendElement( wr::ToWrOpacityProperty(iter.Key(), value->mOpacity)); } } } }
void DOMStorageCache::CloneFrom(const DOMStorageCache* aThat) { // This will never be called on anything else than SessionStorage. // This means mData will never be touched on any other thread than // the main thread and it never went through the loading process. MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(!mPersistent); MOZ_ASSERT(!(bool)aThat->mLoaded); mLoaded = false; mInitialized = aThat->mInitialized; mPersistent = false; mSessionOnlyDataSetActive = aThat->mSessionOnlyDataSetActive; for (uint32_t i = 0; i < kDataSetCount; ++i) { for (auto it = aThat->mData[i].mKeys.ConstIter(); !it.Done(); it.Next()) { mData[i].mKeys.Put(it.Key(), it.UserData()); } ProcessUsageDelta(i, aThat->mData[i].mOriginQuotaUsage); } }
void WebChromeClient::mouseDidMoveOverElement(const HitTestResult& hitTestResult, unsigned modifierFlags) { RefPtr<API::Object> userData; // Notify the bundle client. m_page->injectedBundleUIClient().mouseDidMoveOverElement(m_page, hitTestResult, static_cast<WebEvent::Modifiers>(modifierFlags), userData); // Notify the UIProcess. WebHitTestResultData webHitTestResultData(hitTestResult); m_page->send(Messages::WebPageProxy::MouseDidMoveOverElement(webHitTestResultData, modifierFlags, UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get()))); }
nsresult nsBaseChannel::Redirect(nsIChannel *newChannel, uint32_t redirectFlags, bool openNewChannel) { SUSPEND_PUMP_FOR_SCOPE(); // Transfer properties newChannel->SetLoadGroup(mLoadGroup); newChannel->SetNotificationCallbacks(mCallbacks); newChannel->SetLoadFlags(mLoadFlags | LOAD_REPLACE); // make a copy of the loadinfo, append to the redirectchain // and set it on the new channel if (mLoadInfo) { nsCOMPtr<nsILoadInfo> newLoadInfo = static_cast<mozilla::LoadInfo*>(mLoadInfo.get())->Clone(); nsCOMPtr<nsIPrincipal> uriPrincipal; nsIScriptSecurityManager *sm = nsContentUtils::GetSecurityManager(); sm->GetChannelURIPrincipal(this, getter_AddRefs(uriPrincipal)); bool isInternalRedirect = (redirectFlags & (nsIChannelEventSink::REDIRECT_INTERNAL | nsIChannelEventSink::REDIRECT_STS_UPGRADE)); newLoadInfo->AppendRedirectedPrincipal(uriPrincipal, isInternalRedirect); newChannel->SetLoadInfo(newLoadInfo); } else { // the newChannel was created with a dummy loadInfo, we should clear // it in case the original channel does not have a loadInfo newChannel->SetLoadInfo(nullptr); } // Preserve the privacy bit if it has been overridden if (mPrivateBrowsingOverriden) { nsCOMPtr<nsIPrivateBrowsingChannel> newPBChannel = do_QueryInterface(newChannel); if (newPBChannel) { newPBChannel->SetPrivate(mPrivateBrowsing); } } nsCOMPtr<nsIWritablePropertyBag> bag = ::do_QueryInterface(newChannel); if (bag) { for (auto iter = mPropertyHash.Iter(); !iter.Done(); iter.Next()) { bag->SetProperty(iter.Key(), iter.UserData()); } } // Notify consumer, giving chance to cancel redirect. For backwards compat, // we support nsIHttpEventSink if we are an HTTP channel and if this is not // an internal redirect. RefPtr<nsAsyncRedirectVerifyHelper> redirectCallbackHelper = new nsAsyncRedirectVerifyHelper(); bool checkRedirectSynchronously = !openNewChannel; mRedirectChannel = newChannel; mRedirectFlags = redirectFlags; mOpenRedirectChannel = openNewChannel; nsresult rv = redirectCallbackHelper->Init(this, newChannel, redirectFlags, checkRedirectSynchronously); if (NS_FAILED(rv)) return rv; if (checkRedirectSynchronously && NS_FAILED(mStatus)) return mStatus; return NS_OK; }