Prerender: Add thread checks to PrerenderResourceThrottle

chrome/browser/prerender/prerender_resource_throttle.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/prerender/prerender_resource_throttle.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
@@ skipping 72 matching lines @@
 }
 
 PrerenderResourceThrottle::PrerenderResourceThrottle(net::URLRequest* request)
     : request_(request),
       load_flags_(net::LOAD_NORMAL),
       prerender_throttle_info_(new PrerenderThrottleInfo()) {}
 
 PrerenderResourceThrottle::~PrerenderResourceThrottle() {}
 
 void PrerenderResourceThrottle::WillStartRequest(bool* defer) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   *defer = true;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillStartRequestOnUI, AsWeakPtr(),
                  request_->method(), info->GetResourceType(), request_->url(),
                  info->GetWebContentsGetterForRequest(),
                  prerender_throttle_info_));
 }
 
 void PrerenderResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
     bool* defer) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   *defer = true;
   std::string header;
   request_->GetResponseHeaderByName(kFollowOnlyWhenPrerenderShown, &header);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillRedirectRequestOnUI,
                  AsWeakPtr(), header, info->GetResourceType(), info->IsAsync(),
                  IsNoStoreResponse(*request_), redirect_info.new_url,
                  info->GetWebContentsGetterForRequest()));
 }
 
 void PrerenderResourceThrottle::WillProcessResponse(bool* defer) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   if (!info)
     return;
 
   DCHECK_GT(request_->url_chain().size(), 0u);
   int redirect_count =
       base::saturated_cast<int>(request_->url_chain().size()) - 1;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillProcessResponseOnUI,
                  content::IsResourceTypeFrame(info->GetResourceType()),
                  IsNoStoreResponse(*request_), redirect_count,
                  prerender_throttle_info_));
 }
 
 const char* PrerenderResourceThrottle::GetNameForLogging() const {
   return "PrerenderResourceThrottle";
 }
 
 void PrerenderResourceThrottle::ResumeHandler() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   request_->SetLoadFlags(request_->load_flags() | load_flags_);
   Resume();
 }
 
 // static
 void PrerenderResourceThrottle::WillStartRequestOnUI(
     const base::WeakPtr<PrerenderResourceThrottle>& throttle,
     const std::string& method,
     ResourceType resource_type,
     const GURL& url,
     const ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     scoped_refptr<PrerenderThrottleInfo> prerender_throttle_info) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   bool cancel = false;
   PrerenderContents* prerender_contents =
       PrerenderContentsFromGetter(web_contents_getter);
   if (prerender_contents) {
     DCHECK(prerender_throttle_info);
     prerender_throttle_info->Set(prerender_contents->prerender_mode(),
                                  prerender_contents->origin(),
                                  prerender_contents->prerender_manager());
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
@@ skipping 40 matching lines @@
 
 // static
 void PrerenderResourceThrottle::WillRedirectRequestOnUI(
     const base::WeakPtr<PrerenderResourceThrottle>& throttle,
     const std::string& follow_only_when_prerender_shown_header,
     ResourceType resource_type,
     bool async,
     bool is_no_store,
     const GURL& new_url,
     const ResourceRequestInfo::WebContentsGetter& web_contents_getter) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   bool cancel = false;
   PrerenderContents* prerender_contents =
       PrerenderContentsFromGetter(web_contents_getter);
   if (prerender_contents) {
     prerender_contents->prerender_manager()->RecordPrefetchResponseReceived(
         prerender_contents->origin(),
         content::IsResourceTypeFrame(resource_type), true /* is_redirect */,
         is_no_store);
     // Abort any prerenders with requests which redirect to invalid schemes.
     if (!PrerenderManager::DoesURLHaveValidScheme(new_url)) {
@@ skipping 23 matching lines @@
                         : &PrerenderResourceThrottle::ResumeHandler,
                  throttle));
 }
 
 // static
 void PrerenderResourceThrottle::WillProcessResponseOnUI(
     bool is_main_resource,
     bool is_no_store,
     int redirect_count,
     scoped_refptr<PrerenderThrottleInfo> prerender_throttle_info) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(prerender_throttle_info);
   if (!prerender_throttle_info->manager())
     return;
 
   if (prerender_throttle_info->mode() != PREFETCH_ONLY)
     return;
 
   prerender_throttle_info->manager()->RecordPrefetchResponseReceived(
       prerender_throttle_info->origin(), is_main_resource,
       false /* is_redirect */, is_no_store);
   prerender_throttle_info->manager()->RecordPrefetchRedirectCount(
       prerender_throttle_info->origin(), is_main_resource, redirect_count);
 }
 
 // static
 PrerenderContents* PrerenderResourceThrottle::PrerenderContentsFromGetter(
     const ResourceRequestInfo::WebContentsGetter& web_contents_getter) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (g_prerender_contents_for_testing)
     return g_prerender_contents_for_testing;
   return PrerenderContents::FromWebContents(web_contents_getter.Run());
 }
 
 void PrerenderResourceThrottle::SetPrerenderMode(PrerenderMode mode) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   load_flags_ = (mode == PREFETCH_ONLY) ? net::LOAD_PREFETCH : net::LOAD_NORMAL;
 }
 
 }  // namespace prerender