void WebCookieJar::flush() { // Flush both cookie stores (private and non-private), wait for 2 callbacks. static scoped_refptr<FlushSemaphore> semaphore(new FlushSemaphore()); semaphore->SendFlushRequest(get(false)->cookieStore()->GetCookieMonster()); semaphore->SendFlushRequest(get(true)->cookieStore()->GetCookieMonster()); semaphore->Wait(2); }
void WebRequest::sslClientCert(EVP_PKEY* pkey, scoped_refptr<net::X509Certificate> chain) { base::ScopedOpenSSL<EVP_PKEY, EVP_PKEY_free> privateKey(pkey); if (privateKey.get() == NULL || chain.get() == NULL) { m_request->ContinueWithCertificate(NULL); return; } GURL gurl(m_url); net::OpenSSLPrivateKeyStore::GetInstance()->StorePrivateKey(gurl, privateKey.release()); m_request->ContinueWithCertificate(chain.release()); }
void WebUrlLoaderClient::didReceiveData(scoped_refptr<net::IOBuffer> buf, int size) { if (m_isMainResource && m_isCertMimeType) { m_webFrame->didReceiveData(buf->data(), size); } if (!isActive() || !size) return; // didReceiveData will take a copy of the data if (m_resourceHandle && m_resourceHandle->client()) m_resourceHandle->client()->didReceiveData(m_resourceHandle.get(), buf->data(), size, size); }
namespace android { static Mutex gNetworkThreadLock; static base::Thread *gNetworkThread = NULL; static scoped_refptr<SfRequestContext> gReqContext; static scoped_ptr<net::NetworkChangeNotifier> gNetworkChangeNotifier; bool logMessageHandler( int severity, const char* file, int line, size_t message_start, const std::string& str) { int androidSeverity = ANDROID_LOG_VERBOSE; switch(severity) { case logging::LOG_FATAL: androidSeverity = ANDROID_LOG_FATAL; break; case logging::LOG_ERROR_REPORT: case logging::LOG_ERROR: androidSeverity = ANDROID_LOG_ERROR; break; case logging::LOG_WARNING: androidSeverity = ANDROID_LOG_WARN; break; default: androidSeverity = ANDROID_LOG_VERBOSE; break; } android_printLog(androidSeverity, "chromium-libstagefright", "%s:%d: %s", file, line, str.c_str()); return false; } struct AutoPrioritySaver { AutoPrioritySaver() : mTID(androidGetTid()), mPrevPriority(androidGetThreadPriority(mTID)) { androidSetThreadPriority(mTID, ANDROID_PRIORITY_NORMAL); } ~AutoPrioritySaver() { androidSetThreadPriority(mTID, mPrevPriority); } private: pid_t mTID; int mPrevPriority; DISALLOW_EVIL_CONSTRUCTORS(AutoPrioritySaver); }; static void InitializeNetworkThreadIfNecessary() { Mutex::Autolock autoLock(gNetworkThreadLock); if (gNetworkThread == NULL) { // Make sure any threads spawned by the chromium framework are // running at normal priority instead of inheriting this thread's. AutoPrioritySaver saver; gNetworkThread = new base::Thread("network"); base::Thread::Options options; options.message_loop_type = MessageLoop::TYPE_IO; CHECK(gNetworkThread->StartWithOptions(options)); gReqContext = new SfRequestContext; gNetworkChangeNotifier.reset(net::NetworkChangeNotifier::Create()); net::AndroidNetworkLibrary::RegisterSharedInstance( new SfNetworkLibrary); logging::SetLogMessageHandler(logMessageHandler); } } static void MY_LOGI(const char *s) { LOG_PRI(ANDROID_LOG_INFO, LOG_TAG, "%s", s); } static void MY_LOGV(const char *s) { #if !defined(LOG_NDEBUG) || LOG_NDEBUG == 0 LOG_PRI(ANDROID_LOG_VERBOSE, LOG_TAG, "%s", s); #endif } SfNetLog::SfNetLog() : mNextID(1) { } void SfNetLog::AddEntry( EventType type, const base::TimeTicks &time, const Source &source, EventPhase phase, EventParameters *params) { #if 0 MY_LOGI(StringPrintf( "AddEntry time=%s type=%s source=%s phase=%s\n", TickCountToString(time).c_str(), EventTypeToString(type), SourceTypeToString(source.type), EventPhaseToString(phase)).c_str()); #endif } uint32 SfNetLog::NextID() { return mNextID++; } net::NetLog::LogLevel SfNetLog::GetLogLevel() const { return LOG_ALL; } //////////////////////////////////////////////////////////////////////////////// SfRequestContext::SfRequestContext() { mUserAgent = MakeUserAgent().c_str(); set_net_log(new SfNetLog()); set_host_resolver( net::CreateSystemHostResolver( net::HostResolver::kDefaultParallelism, NULL /* resolver_proc */, net_log())); set_ssl_config_service( net::SSLConfigService::CreateSystemSSLConfigService()); mProxyConfigService = new net::ProxyConfigServiceAndroid; set_proxy_service(net::ProxyService::CreateWithoutProxyResolver( mProxyConfigService, net_log())); set_http_transaction_factory(new net::HttpCache( host_resolver(), new net::CertVerifier(), dnsrr_resolver(), dns_cert_checker(), proxy_service(), ssl_config_service(), net::HttpAuthHandlerFactory::CreateDefault(host_resolver()), network_delegate(), net_log(), NULL)); // backend_factory set_cookie_store(new net::CookieMonster(NULL, NULL)); } const std::string &SfRequestContext::GetUserAgent(const GURL &url) const { return mUserAgent; } status_t SfRequestContext::updateProxyConfig( const char *host, int32_t port, const char *exclusionList) { Mutex::Autolock autoLock(mProxyConfigLock); if (host == NULL || *host == '\0') { MY_LOGV("updateProxyConfig NULL"); std::string proxy; std::string exList; mProxyConfigService->UpdateProxySettings(proxy, exList); } else { #if !defined(LOG_NDEBUG) || LOG_NDEBUG == 0 LOG_PRI(ANDROID_LOG_VERBOSE, LOG_TAG, "updateProxyConfig %s:%d, exclude '%s'", host, port, exclusionList); #endif std::string proxy = StringPrintf("%s:%d", host, port).c_str(); std::string exList = exclusionList; mProxyConfigService->UpdateProxySettings(proxy, exList); } return OK; } //////////////////////////////////////////////////////////////////////////////// SfNetworkLibrary::SfNetworkLibrary() {} SfNetworkLibrary::VerifyResult SfNetworkLibrary::VerifyX509CertChain( const std::vector<std::string>& cert_chain, const std::string& hostname, const std::string& auth_type) { return VERIFY_OK; } //////////////////////////////////////////////////////////////////////////////// SfDelegate::SfDelegate() : mOwner(NULL), mURLRequest(NULL), mReadBuffer(new net::IOBufferWithSize(8192)), mNumBytesRead(0), mNumBytesTotal(0), mDataDestination(NULL), mAtEOS(false) { InitializeNetworkThreadIfNecessary(); } SfDelegate::~SfDelegate() { CHECK(mURLRequest == NULL); } // static status_t SfDelegate::UpdateProxyConfig( const char *host, int32_t port, const char *exclusionList) { InitializeNetworkThreadIfNecessary(); return gReqContext->updateProxyConfig(host, port, exclusionList); } void SfDelegate::setOwner(ChromiumHTTPDataSource *owner) { mOwner = owner; } void SfDelegate::setUID(uid_t uid) { gReqContext->setUID(uid); } bool SfDelegate::getUID(uid_t *uid) const { return gReqContext->getUID(uid); } void SfDelegate::OnReceivedRedirect( net::URLRequest *request, const GURL &new_url, bool *defer_redirect) { MY_LOGV("OnReceivedRedirect"); } void SfDelegate::OnAuthRequired( net::URLRequest *request, net::AuthChallengeInfo *auth_info) { MY_LOGV("OnAuthRequired"); inherited::OnAuthRequired(request, auth_info); } void SfDelegate::OnCertificateRequested( net::URLRequest *request, net::SSLCertRequestInfo *cert_request_info) { MY_LOGV("OnCertificateRequested"); inherited::OnCertificateRequested(request, cert_request_info); } void SfDelegate::OnSSLCertificateError( net::URLRequest *request, int cert_error, net::X509Certificate *cert) { fprintf(stderr, "OnSSLCertificateError cert_error=%d\n", cert_error); inherited::OnSSLCertificateError(request, cert_error, cert); } void SfDelegate::OnGetCookies(net::URLRequest *request, bool blocked_by_policy) { MY_LOGV("OnGetCookies"); } void SfDelegate::OnSetCookie( net::URLRequest *request, const std::string &cookie_line, const net::CookieOptions &options, bool blocked_by_policy) { MY_LOGV("OnSetCookie"); } void SfDelegate::OnResponseStarted(net::URLRequest *request) { if (request->status().status() != net::URLRequestStatus::SUCCESS) { MY_LOGI(StringPrintf( "Request failed with status %d and os_error %d", request->status().status(), request->status().os_error()).c_str()); delete mURLRequest; mURLRequest = NULL; mOwner->onConnectionFailed(ERROR_IO); return; } else if (mRangeRequested && request->GetResponseCode() != 206) { MY_LOGI(StringPrintf( "We requested a content range, but server didn't " "support that. (responded with %d)", request->GetResponseCode()).c_str()); delete mURLRequest; mURLRequest = NULL; mOwner->onConnectionFailed(-EPIPE); return; } else if ((request->GetResponseCode() / 100) != 2) { MY_LOGI(StringPrintf( "Server responded with http status %d", request->GetResponseCode()).c_str()); delete mURLRequest; mURLRequest = NULL; mOwner->onConnectionFailed(ERROR_IO); return; } MY_LOGV("OnResponseStarted"); std::string headers; request->GetAllResponseHeaders(&headers); MY_LOGV(StringPrintf("response headers: %s", headers.c_str()).c_str()); std::string contentType; request->GetResponseHeaderByName("Content-Type", &contentType); mOwner->onConnectionEstablished( request->GetExpectedContentSize(), contentType.c_str()); } void SfDelegate::OnReadCompleted(net::URLRequest *request, int bytes_read) { if (bytes_read == -1) { MY_LOGI(StringPrintf( "OnReadCompleted, read failed, status %d", request->status().status()).c_str()); mOwner->onReadCompleted(ERROR_IO); return; } MY_LOGV(StringPrintf("OnReadCompleted, read %d bytes", bytes_read).c_str()); if (bytes_read < 0) { MY_LOGI(StringPrintf( "Read failed w/ status %d\n", request->status().status()).c_str()); mOwner->onReadCompleted(ERROR_IO); return; } else if (bytes_read == 0) { mAtEOS = true; mOwner->onReadCompleted(mNumBytesRead); return; } CHECK_GT(bytes_read, 0); CHECK_LE(mNumBytesRead + bytes_read, mNumBytesTotal); memcpy((uint8_t *)mDataDestination + mNumBytesRead, mReadBuffer->data(), bytes_read); mNumBytesRead += bytes_read; readMore(request); } void SfDelegate::readMore(net::URLRequest *request) { while (mNumBytesRead < mNumBytesTotal) { size_t copy = mNumBytesTotal - mNumBytesRead; if (copy > mReadBuffer->size()) { copy = mReadBuffer->size(); } int n; if (request->Read(mReadBuffer, copy, &n)) { MY_LOGV(StringPrintf("Read %d bytes directly.", n).c_str()); CHECK_LE((size_t)n, copy); memcpy((uint8_t *)mDataDestination + mNumBytesRead, mReadBuffer->data(), n); mNumBytesRead += n; if (n == 0) { mAtEOS = true; break; } } else { MY_LOGV("readMore pending read"); if (request->status().status() != net::URLRequestStatus::IO_PENDING) { MY_LOGI(StringPrintf( "Direct read failed w/ status %d\n", request->status().status()).c_str()); mOwner->onReadCompleted(ERROR_IO); return; } return; } } mOwner->onReadCompleted(mNumBytesRead); } void SfDelegate::initiateConnection( const char *uri, const KeyedVector<String8, String8> *headers, off64_t offset) { GURL url(uri); MessageLoop *loop = gNetworkThread->message_loop(); loop->PostTask( FROM_HERE, NewRunnableFunction( &SfDelegate::OnInitiateConnectionWrapper, this, url, headers, offset)); } // static void SfDelegate::OnInitiateConnectionWrapper( SfDelegate *me, GURL url, const KeyedVector<String8, String8> *headers, off64_t offset) { me->onInitiateConnection(url, headers, offset); } void SfDelegate::onInitiateConnection( const GURL &url, const KeyedVector<String8, String8> *extra, off64_t offset) { CHECK(mURLRequest == NULL); mURLRequest = new net::URLRequest(url, this); mAtEOS = false; mRangeRequested = false; if (offset != 0 || extra != NULL) { net::HttpRequestHeaders headers = mURLRequest->extra_request_headers(); if (offset != 0) { headers.AddHeaderFromString( StringPrintf("Range: bytes=%lld-", offset).c_str()); mRangeRequested = true; } if (extra != NULL) { for (size_t i = 0; i < extra->size(); ++i) { AString s; s.append(extra->keyAt(i).string()); s.append(": "); s.append(extra->valueAt(i).string()); headers.AddHeaderFromString(s.c_str()); } } mURLRequest->SetExtraRequestHeaders(headers); } mURLRequest->set_context(gReqContext); mURLRequest->Start(); } void SfDelegate::initiateDisconnect() { MessageLoop *loop = gNetworkThread->message_loop(); loop->PostTask( FROM_HERE, NewRunnableFunction( &SfDelegate::OnInitiateDisconnectWrapper, this)); } // static void SfDelegate::OnInitiateDisconnectWrapper(SfDelegate *me) { me->onInitiateDisconnect(); } void SfDelegate::onInitiateDisconnect() { if (mURLRequest == NULL) { return; } mURLRequest->Cancel(); delete mURLRequest; mURLRequest = NULL; mOwner->onDisconnectComplete(); } void SfDelegate::initiateRead(void *data, size_t size) { MessageLoop *loop = gNetworkThread->message_loop(); loop->PostTask( FROM_HERE, NewRunnableFunction( &SfDelegate::OnInitiateReadWrapper, this, data, size)); } // static void SfDelegate::OnInitiateReadWrapper( SfDelegate *me, void *data, size_t size) { me->onInitiateRead(data, size); } void SfDelegate::onInitiateRead(void *data, size_t size) { CHECK(mURLRequest != NULL); mNumBytesRead = 0; mNumBytesTotal = size; mDataDestination = data; if (mAtEOS) { mOwner->onReadCompleted(0); return; } readMore(mURLRequest); } } // namespace android
bool SfDelegate::getUID(uid_t *uid) const { return gReqContext->getUID(uid); }
void SfDelegate::setUID(uid_t uid) { gReqContext->setUID(uid); }
// static status_t SfDelegate::UpdateProxyConfig( const char *host, int32_t port, const char *exclusionList) { InitializeNetworkThreadIfNecessary(); return gReqContext->updateProxyConfig(host, port, exclusionList); }
bool RootWindow::IsSame(scoped_refptr<RootWindow> Wnd) { if (Wnd->GetBrowser()->GetIdentifier() == Wnd->GetBrowser()->GetIdentifier()) return true; return false; }
void RebuildTable(const scoped_refptr<URLEnumerator>& enumerator) { enumerator->OnComplete(true); }
bool RefCountedMemory::Equals( const scoped_refptr<RefCountedMemory>& other) const { return other.get() && size() == other->size() && (memcmp(front(), other->front(), size()) == 0); }