BackgroundJobProcessor::~BackgroundJobProcessor() { // This should appear to be called from the same thread from which this instance was created Assert(IsClosed()); if (parallelThreadData) { for (unsigned int i = 0; i < this->threadCount; i++) { HeapDelete(parallelThreadData[i]); } HeapDeleteArray(this->maxThreadCount, parallelThreadData); } }
already_AddRefed<Promise> MediaKeySession::Update(const ArrayBufferViewOrArrayBuffer& aResponse, ErrorResult& aRv) { nsRefPtr<DetailedPromise> promise(MakePromise(aRv)); if (aRv.Failed()) { return nullptr; } nsTArray<uint8_t> data; if (IsClosed() || !mKeys->GetCDMProxy()) { promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR, NS_LITERAL_CSTRING("Session is closed or was not properly initialized")); EME_LOG("MediaKeySession[%p,'%s'] Update() failed, session is closed or was not properly initialised.", this, NS_ConvertUTF16toUTF8(mSessionId).get()); return promise.forget(); } if (!CopyArrayBufferViewOrArrayBufferData(aResponse, data)) { promise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR, NS_LITERAL_CSTRING("Invalid response buffer")); EME_LOG("MediaKeySession[%p,'%s'] Update() failed, invalid response buffer", this, NS_ConvertUTF16toUTF8(mSessionId).get()); return promise.forget(); } #ifdef PR_LOGGING // Convert response to base64 for easier logging. // Note: UpdateSession() Move()s the data out of the array, so we have // to copy it here. nsAutoCString base64Response; nsDependentCSubstring rawResponse(reinterpret_cast<const char*>(data.Elements()), data.Length()); if (NS_FAILED(Base64Encode(rawResponse, base64Response))) { NS_WARNING("Failed to base64 encode response for logging"); } #endif PromiseId pid = mKeys->StorePromise(promise); mKeys->GetCDMProxy()->UpdateSession(mSessionId, pid, data); EME_LOG("MediaKeySession[%p,'%s'] Update() sent to CDM, " "promiseId=%d Response(base64)='%s'", this, NS_ConvertUTF16toUTF8(mSessionId).get(), pid, base64Response.get()); return promise.forget(); }
bool BackgroundJobProcessor::RemoveJob(Job *const job) { // This function is called from inside the lock Assert(job); Assert(managers.Contains(job->Manager())); Assert(!IsClosed()); if (IsBeingProcessed(job)) { return false; } return __super::RemoveJob(job); }
bool ON_ArcCurve::IsContinuous( ON::continuity c, double t, int*, // hint - formal parameter intentionally ignored in this virtual function double, // point_tolerance - formal parameter intentionally ignored in this virtual function double, // d1_tolerance - formal parameter intentionally ignored in this virtual function double, // d2_tolerance - formal parameter intentionally ignored in this virtual function double, // cos_angle_tolerance - formal parameter intentionally ignored in this virtual function double // curvature_tolerance - formal parameter intentionally ignored in this virtual function ) const { // 20 March 2003 Dale Lear // Added this override of IsContinuous() to // speed queries and support the // locus favors of ON::continuity. bool rc = true; if ( !IsClosed() ) { switch(c) { case ON::unknown_continuity: case ON::C0_continuous: case ON::C1_continuous: case ON::C2_continuous: case ON::G1_continuous: case ON::G2_continuous: case ON::Cinfinity_continuous: case ON::Gsmooth_continuous: // rc = true; break; case ON::C0_locus_continuous: case ON::C1_locus_continuous: case ON::C2_locus_continuous: case ON::G1_locus_continuous: case ON::G2_locus_continuous: // open arc is locus discontinuous at end parameter. // By convention (see ON::continuity comments) it // is locus continuous at start parameter. if ( t >= Domain()[1] ) rc = false; break; } } return rc; }
NS_IMETHODIMP nsBaseContentStream::ReadSegments(nsWriteSegmentFun fun, void *closure, PRUint32 count, PRUint32 *result) { *result = 0; if (mStatus == NS_BASE_STREAM_CLOSED) return NS_OK; // No data yet if (!IsClosed() && IsNonBlocking()) return NS_BASE_STREAM_WOULD_BLOCK; return mStatus; }
int ON_Surface::IsAtSeam(double s, double t) const { int rc = 0; int i; for (i=0; i<2; i++){ if (!IsClosed(i)) continue; double p = (i) ? t : s; if (p == Domain(i)[0] || p == Domain(i)[1]) rc += (i+1); } return rc; }
void BackgroundJobProcessor::AddJob(Job *const job, const bool prioritize) { // This function is called from inside the lock Assert(job); Assert(managers.Contains(job->Manager())); Assert(!IsClosed()); if(numJobs + 1 == 0) Js::Throw::OutOfMemory(); // Overflow: job counts we use are int32's. ++numJobs; __super::AddJob(job, prioritize); IndicateNewJob(); }
already_AddRefed<Promise> MediaKeySession::Close(ErrorResult& aRv) { nsRefPtr<Promise> promise(mKeys->MakePromise(aRv)); if (aRv.Failed()) { return nullptr; } if (IsClosed() || !mKeys->GetCDMProxy()) { promise->MaybeResolve(JS::UndefinedHandleValue); return promise.forget(); } mKeys->GetCDMProxy()->CloseSession(mSessionId, mKeys->StorePromise(promise)); return promise.forget(); }
// static IndexedDatabaseManager* IndexedDatabaseManager::GetOrCreate() { NS_ASSERTION(NS_IsMainThread(), "Wrong thread!"); if (IsClosed()) { NS_ERROR("Calling GetOrCreate() after shutdown!"); return nullptr; } if (!gDBManager) { sIsMainProcess = XRE_IsParentProcess(); if (sIsMainProcess && Preferences::GetBool("disk_space_watcher.enabled", false)) { // See if we're starting up in low disk space conditions. nsCOMPtr<nsIDiskSpaceWatcher> watcher = do_GetService(DISKSPACEWATCHER_CONTRACTID); if (watcher) { bool isDiskFull; if (NS_SUCCEEDED(watcher->GetIsDiskFull(&isDiskFull))) { sLowDiskSpaceMode = isDiskFull; } else { NS_WARNING("GetIsDiskFull failed!"); } } else { NS_WARNING("No disk space watcher component available!"); } } RefPtr<IndexedDatabaseManager> instance(new IndexedDatabaseManager()); nsresult rv = instance->Init(); NS_ENSURE_SUCCESS(rv, nullptr); if (gInitialized.exchange(true)) { NS_ERROR("Initialized more than once?!"); } gDBManager = instance; ClearOnShutdown(&gDBManager); } return gDBManager; }
void BackgroundJobProcessor::AddManager(JobManager *const manager) { Assert(manager); IterateBackgroundThreads([&manager](ParallelThreadData *threadData){ manager->ProcessorThreadSpecificCallBack(threadData->GetPageAllocator()); return false; }); AutoCriticalSection lock(&criticalSection); Assert(!IsClosed()); JobProcessor::AddManager(manager); IndicateNewJob(); }
already_AddRefed<Promise> MediaKeySession::Close(ErrorResult& aRv) { RefPtr<DetailedPromise> promise(MakePromise(aRv, NS_LITERAL_CSTRING("MediaKeySession.close"))); if (aRv.Failed()) { return nullptr; } // 1. Let session be the associated MediaKeySession object. // 2. If session is closed, return a resolved promise. if (IsClosed()) { EME_LOG("MediaKeySession[%p,'%s'] Close() already closed", this, NS_ConvertUTF16toUTF8(mSessionId).get()); promise->MaybeResolveWithUndefined(); return promise.forget(); } // 3. If session's callable value is false, return a promise rejected // with an InvalidStateError. if (!IsCallable()) { EME_LOG("MediaKeySession[%p,''] Close() called before sessionId set by CDM", this); promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR, NS_LITERAL_CSTRING("MediaKeySession.Close() called before sessionId set by CDM")); return promise.forget(); } if (!mKeys->GetCDMProxy()) { EME_LOG("MediaKeySession[%p,'%s'] Close() null CDMProxy", this, NS_ConvertUTF16toUTF8(mSessionId).get()); promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR, NS_LITERAL_CSTRING("MediaKeySession.Close() lost reference to CDM")); return promise.forget(); } // 4. Let promise be a new promise. PromiseId pid = mKeys->StorePromise(promise); // 5. Run the following steps in parallel: // 5.1 Let cdm be the CDM instance represented by session's cdm instance value. // 5.2 Use cdm to close the session associated with session. mKeys->GetCDMProxy()->CloseSession(mSessionId, pid); EME_LOG("MediaKeySession[%p,'%s'] Close() sent to CDM, promiseId=%d", this, NS_ConvertUTF16toUTF8(mSessionId).get(), pid); // Session Closed algorithm is run when CDM causes us to run OnSessionClosed(). // 6. Return promise. return promise.forget(); }
const OPT<SHAPE_LINE_CHAIN::INTERSECTION> SHAPE_LINE_CHAIN::SelfIntersecting() const { for( int s1 = 0; s1 < SegmentCount(); s1++ ) { for( int s2 = s1 + 1; s2 < SegmentCount(); s2++ ) { const VECTOR2I s2a = CSegment( s2 ).A, s2b = CSegment( s2 ).B; if( s1 + 1 != s2 && CSegment( s1 ).Contains( s2a ) ) { INTERSECTION is; is.our = CSegment( s1 ); is.their = CSegment( s2 ); is.p = s2a; return is; } else if( CSegment( s1 ).Contains( s2b ) && // for closed polylines, the ending point of the // last segment == starting point of the first segment // this is a normal case, not self intersecting case !( IsClosed() && s1 == 0 && s2 == SegmentCount()-1 ) ) { INTERSECTION is; is.our = CSegment( s1 ); is.their = CSegment( s2 ); is.p = s2b; return is; } else { OPT_VECTOR2I p = CSegment( s1 ).Intersect( CSegment( s2 ), true ); if( p ) { INTERSECTION is; is.our = CSegment( s1 ); is.their = CSegment( s2 ); is.p = *p; return is; } } } } return OPT<SHAPE_LINE_CHAIN::INTERSECTION>(); }
/**--------------------------------------------------------------------------<BR> C2DLineBaseSet::AddIfCommonEnd \brief Adds the points of another to this if they have a common end which is either the first or last point. Returns true if there was a match. <P>---------------------------------------------------------------------------*/ bool C2DLineBaseSet::AddIfCommonEnd(C2DLineBaseSet& Other) { assert(!IsClosed()); assert(!Other.IsClosed()); int nThisCount = size() ; if (nThisCount < 1) return false; int nOtherCount = Other.size(); if (nOtherCount < 1) return false; if ( GetAt(0)->GetPointFrom() == Other.GetAt(0)->GetPointFrom()) { ReverseDirection(); *this << Other; return true; } else if( GetAt(0)->GetPointFrom() == Other.GetAt(nOtherCount - 1)->GetPointTo() ) { ReverseDirection(); Other.ReverseDirection(); *this << Other; return true; } else if (GetAt(nThisCount - 1)->GetPointTo() == Other.GetAt(0)->GetPointFrom()) { *this << Other; return true; } else if (GetAt(nThisCount - 1)->GetPointTo() == Other.GetAt(nOtherCount - 1)->GetPointTo() ) { Other.ReverseDirection(); *this << Other; return true; } return false; }
bool CZipArchive::SetGlobalComment(const CString &szComment) { if (IsClosed()) { TRACE(_T("ZipArchive is closed.\n")); return false; } if (m_storage.IsSpanMode() == -1) { TRACE(_T("You cannot modify the global comment of the existing disk spanning archive.\n")); return false; } m_centralDir.m_szComment = szComment; m_centralDir.RemoveFromDisk(); return true; }
void JobProcessor::AddJob(Job *const job, const bool prioritize) { // This function is called from inside the lock Assert(job); Assert(managers.Contains(job->Manager())); Assert(!IsClosed()); if (job->Manager()->numJobsAddedToProcessor + 1 == 0) Js::Throw::OutOfMemory(); // Overflow: job counts we use are int32's. ++job->Manager()->numJobsAddedToProcessor; if (prioritize) jobs.LinkToBeginning(job); else jobs.LinkToEnd(job); }
NS_IMETHODIMP nsFileUploadContentStream::AsyncWait(nsIInputStreamCallback *callback, uint32_t flags, uint32_t count, nsIEventTarget *target) { nsresult rv = nsBaseContentStream::AsyncWait(callback, flags, count, target); if (NS_FAILED(rv) || IsClosed()) return rv; if (IsNonBlocking()) { nsCOMPtr<nsIRunnable> callback = NS_NewRunnableMethod(this, &nsFileUploadContentStream::OnCopyComplete); mCopyEvent->Dispatch(callback, mSink, target); } return NS_OK; }
void BaseSession::Recv(Array& raw_data) { if (IsClosed()) return; stream_ibuffer_.Insert(stream_ibuffer_.End(), raw_data.Begin(), raw_data.Size()); for (;;) { if (stream_ibuffer_.Size() < 2) return; uint16_t len = *reinterpret_cast<uint16_t *>(stream_ibuffer_.Begin()); if (stream_ibuffer_.Size() < 2 + len) return; Array proto(static_cast<char *>(stream_ibuffer_.Begin())+2, len); OnAfterRecv(proto); stream_ibuffer_.Erase(stream_ibuffer_.Begin(), 2+len); } }
bool ON_NurbsCurve::Morph( const ON_SpaceMorph& morph ) { DestroyCurveTree(); ON_BOOL32 bIsClosed = IsClosed(); ON_BOOL32 bIsPeriodic = IsPeriodic(); morph.MorphPointList( m_dim, m_is_rat, m_cv_count, m_cv_stride, m_cv ); if ( bIsPeriodic ) { int i, deg = m_order-1; for ( i = 0; i < deg; i++ ) SetCV( m_cv_count-deg+i, ON::intrinsic_point_style, CV(i) ); } else if ( bIsClosed ) { SetCV( m_cv_count-1, ON::intrinsic_point_style, CV(0) ); } return true; }
int CZipArchive::FindFile(CString szFileName, bool bCaseSensitive) { if (IsClosed()) { TRACE(_T("ZipArchive is closed.\n")); return (int)-1; } for (WORD i = 0; i < GetNoEntries(); i++) { CFileHeader fh; GetFileInfo(fh, i); CString temp = fh.m_szFileName; if ((bCaseSensitive ? temp.Collate(szFileName) : temp.CollateNoCase(szFileName)) == 0) return (int)i; } return (int) - 1; }
bool CZipArchive::GetFileInfo(CFileHeader & fhInfo, WORD uIndex) { if (IsClosed()) { TRACE(_T("ZipArchive is closed.\n")); return false; } if (!m_centralDir.IsValidIndex(uIndex)) return false; fhInfo = *(m_centralDir.m_headers[uIndex]); //if (m_bOemCompatible) // fhInfo.m_szFileName.OemToAnsi(); if (m_bSlashChange) fhInfo.m_szFileName.Replace(_T('/'), _T('\\')); return true; }
void MediaKeySession::DispatchKeysChange() { if (IsClosed()) { return; } DebugOnly<nsresult> rv = nsContentUtils::DispatchTrustedEvent(mKeys->GetOwnerDoc(), this, NS_LITERAL_STRING("keyschange"), false, false); #ifdef DEBUG if (NS_FAILED(rv)) { NS_WARNING("Failed to dispatch keyschange event"); } #endif }
bool AbstractTaskFactory::Validate() { ClearValidationErrors(); bool valid = true; if (!task.HasStart()) { AddValidationError(TaskValidationErrorType::NO_VALID_START); valid = false; } if (!task.HasFinish()) { AddValidationError(TaskValidationErrorType::NO_VALID_FINISH); valid = false; } if (constraints.is_closed && !IsClosed()) { AddValidationError(TaskValidationErrorType::TASK_NOT_CLOSED); valid = false; } if (constraints.IsFixedSize()) { if (task.TaskSize() != constraints.max_points) { AddValidationError(TaskValidationErrorType::INCORRECT_NUMBER_TURNPOINTS); valid = false; } } else { if (task.TaskSize() < constraints.min_points) { AddValidationError(TaskValidationErrorType::UNDER_MIN_TURNPOINTS); valid = false; } if (task.TaskSize() > constraints.max_points) { AddValidationError(TaskValidationErrorType::EXCEEDS_MAX_TURNPOINTS); valid = false; } } if (constraints.homogeneous_tps && !IsHomogeneous()) { AddValidationError(TaskValidationErrorType::TASK_NOT_HOMOGENEOUS); valid = false; } return valid; }
already_AddRefed<Promise> MediaKeySession::Update(const ArrayBufferViewOrArrayBuffer& aResponse, ErrorResult& aRv) { nsRefPtr<Promise> promise(mKeys->MakePromise(aRv)); if (aRv.Failed()) { return nullptr; } nsTArray<uint8_t> data; if (IsClosed() || !mKeys->GetCDMProxy() || !CopyArrayBufferViewOrArrayBufferData(aResponse, data)) { promise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR); return promise.forget(); } mKeys->GetCDMProxy()->UpdateSession(mSessionId, mKeys->StorePromise(promise), data); return promise.forget(); }
void Socket::start_async_send() { if( IsClosed() ) return; if( m_OutActive ) return; if ( m_OutBuffer->length() == 0 ) { m_OutActive = false; return; } m_OutActive = true; m_socket.async_write_some( boost::asio::buffer( m_OutBuffer->rd_ptr(), m_OutBuffer->length() ), boost::bind( &Socket::on_write_complete, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred ) ); }
already_AddRefed<Promise> MediaKeySession::Remove(ErrorResult& aRv) { nsRefPtr<Promise> promise(mKeys->MakePromise(aRv)); if (aRv.Failed()) { return nullptr; } if (mSessionType != SessionType::Persistent) { promise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR); // "The operation is not supported on session type sessions." return promise.forget(); } if (IsClosed() || !mKeys->GetCDMProxy()) { promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR); // "The session is closed." return promise.forget(); } mKeys->GetCDMProxy()->RemoveSession(mSessionId, mKeys->StorePromise(promise)); return promise.forget(); }
bool CZipArchive::SetFileComment(WORD uIndex, CString szComment) { if (IsClosed()) { TRACE(_T("ZipArchive is closed.\n")); return false; } if (m_storage.IsSpanMode() == -1) { TRACE(_T("You cannot modify the global comment of the existing disk spanning archive.\n")); return false; } if (!m_centralDir.IsValidIndex(uIndex)) return false; m_centralDir.m_headers[uIndex]->m_szComment = szComment; m_centralDir.m_headers[uIndex]->ValidateComment(); m_centralDir.RemoveFromDisk(); return true; }
///////////////////////////////////////////////////////////////////////////// // Test for angle ///////////////////////////////////////////////////////////////////////////// bool CDiscretizedLine::IsAngle(int i) const { if ((i == 0 || i == Size() - 1) && !IsClosed()) return true; int Next = NextIndex(i); int Prev = PreviousIndex(i); double x1 = vx[Next] - vx[i]; double y1 = vy[Next] - vy[i]; double x2 = vx[Prev] - vx[i]; double y2 = vy[Prev] - vy[i]; double det = x1 * y2 - x2 * y1; double n1 = x1 * x1 + y1 * y1; double n2 = x2 * x2 + y2 * y2; return std::fabs(det / std::sqrt(n1 * n2)) > 0.4; // ??? }
void Socket::close() { if( IsClosed() ) return; m_closing = true; try { if( m_socket.is_open() ) { m_socket.shutdown( boost::asio::socket_base::shutdown_both ); m_socket.close(); } } catch( boost::system::error_code& e) { sLog.outError("Socket::close: error occurred while closing socket = %s", e.message().c_str()); } }
void CMission::OnNewSystem (CSystem *pSystem) // OnNewSystem // // We are in a new system { // Ignore any closed missions (completed missions) if (IsClosed()) return; // Resolve owner m_pOwner.Resolve(); // Clear any object references (because they might belong to a different // system). ClearObjReferences(); }
already_AddRefed<Promise> MediaKeySession::Close(ErrorResult& aRv) { nsRefPtr<Promise> promise(mKeys->MakePromise(aRv)); if (aRv.Failed()) { return nullptr; } if (IsClosed() || !mKeys->GetCDMProxy()) { EME_LOG("MediaKeySession[%p,'%s'] Close() already closed", this, NS_ConvertUTF16toUTF8(mSessionId).get()); promise->MaybeResolve(JS::UndefinedHandleValue); return promise.forget(); } PromiseId pid = mKeys->StorePromise(promise); mKeys->GetCDMProxy()->CloseSession(mSessionId, mKeys->StorePromise(promise)); EME_LOG("MediaKeySession[%p,'%s'] Close() sent to CDM, promiseId=%d", this, NS_ConvertUTF16toUTF8(mSessionId).get(), pid); return promise.forget(); }