Move most of the remaining users of WebContentsObserver::tab_contents() to use web_contents().

chrome/browser/safe_browsing/client_side_detection_host.cc

 // Copyright (c) 2011 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/safe_browsing/client_side_detection_host.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/task.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/browser_feature_extractor.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "chrome/common/safe_browsing/safebrowsing_messages.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_request_details.h"
-#include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "googleurl/src/gurl.h"
 
 using content::BrowserThread;
 using content::WebContents;
 
 namespace safe_browsing {
 
 // This class is instantiated each time a new toplevel URL loads, and
 // asynchronously checks whether the phishing classifier should run for this
 // URL.  If so, it notifies the renderer with a StartPhishingDetection IPC.
 // Objects of this class are ref-counted and will be destroyed once nobody
 // uses it anymore.  If |tab_contents|, |csd_service| or |host| go away you need
 // to call Cancel().  We keep the |sb_service| alive in a ref pointer for as
 // long as it takes.
 class ClientSideDetectionHost::ShouldClassifyUrlRequest
     : public base::RefCountedThreadSafe<
           ClientSideDetectionHost::ShouldClassifyUrlRequest> {
  public:
   ShouldClassifyUrlRequest(const content::FrameNavigateParams& params,
-                           TabContents* tab_contents,
+                           WebContents* web_contents,
                            ClientSideDetectionService* csd_service,
                            SafeBrowsingService* sb_service,
                            ClientSideDetectionHost* host)
       : canceled_(false),
         params_(params),
-        tab_contents_(tab_contents),
+        web_contents_(web_contents),
         csd_service_(csd_service),
         sb_service_(sb_service),
         host_(host) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    DCHECK(tab_contents_);
+    DCHECK(web_contents_);
     DCHECK(csd_service_);
     DCHECK(sb_service_);
     DCHECK(host_);
   }
 
   void Start() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     // We start by doing some simple checks that can run on the UI thread.
     UMA_HISTOGRAM_COUNTS("SBClientPhishing.ClassificationStart", 1);
@@ skipping 14 matching lines @@
       VLOG(1) << "Skipping phishing classification for URL: " << params_.url
               << " because of hosting on private IP: "
               << params_.socket_address.host();
       UMA_HISTOGRAM_ENUMERATION("SBClientPhishing.PreClassificationCheckFail",
                                 NO_CLASSIFY_PRIVATE_IP,
                                 NO_CLASSIFY_MAX);
       return;
     }
 
     // Don't run the phishing classifier if the tab is incognito.
-    if (tab_contents_->GetBrowserContext()->IsOffTheRecord()) {
+    if (web_contents_->GetBrowserContext()->IsOffTheRecord()) {
       VLOG(1) << "Skipping phishing classification for URL: " << params_.url
               << " because we're browsing incognito.";
       UMA_HISTOGRAM_ENUMERATION("SBClientPhishing.PreClassificationCheckFail",
                                 NO_CLASSIFY_OFF_THE_RECORD,
                                 NO_CLASSIFY_MAX);
 
       return;
     }
 
     // We lookup the csd-whitelist before we lookup the cache because
     // a URL may have recently been whitelisted.  If the URL matches
     // the csd-whitelist we won't start classification.  The
     // csd-whitelist check has to be done on the IO thread because it
     // uses the SafeBrowsing service class.
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&ShouldClassifyUrlRequest::CheckCsdWhitelist,
                    this, params_.url));
   }
 
   void Cancel() {
     canceled_ = true;
     // Just to make sure we don't do anything stupid we reset all these
     // pointers except for the safebrowsing service class which may be
     // accessed by CheckCsdWhitelist().
-    tab_contents_ = NULL;
+    web_contents_ = NULL;
     csd_service_ = NULL;
     host_ = NULL;
   }
 
  private:
   friend class base::RefCountedThreadSafe<
       ClientSideDetectionHost::ShouldClassifyUrlRequest>;
 
   // Enum used to keep stats about why the pre-classification check failed.
   enum PreClassificationCheckFailures {
@@ skipping 55 matching lines @@
     } else if (csd_service_->OverReportLimit()) {
       VLOG(1) << "Too many report phishing requests sent recently, "
               << "not running classification for " << params_.url;
       UMA_HISTOGRAM_ENUMERATION("SBClientPhishing.PreClassificationCheckFail",
                                 NO_CLASSIFY_TOO_MANY_REPORTS,
                                 NO_CLASSIFY_MAX);
       return;
     }
 
     // Everything checks out, so start classification.
-    // |tab_contents_| is safe to call as we will be destructed
+    // |web_contents_| is safe to call as we will be destructed
     // before it is.
     VLOG(1) << "Instruct renderer to start phishing detection for URL: "
             << params_.url;
-    RenderViewHost* rvh = tab_contents_->GetRenderViewHost();
+    RenderViewHost* rvh = web_contents_->GetRenderViewHost();
     rvh->Send(new SafeBrowsingMsg_StartPhishingDetection(
         rvh->routing_id(), params_.url));
   }
 
   // No need to protect |canceled_| with a lock because it is only read and
   // written by the UI thread.
   bool canceled_;
   content::FrameNavigateParams params_;
-  TabContents* tab_contents_;
+  WebContents* web_contents_;
   ClientSideDetectionService* csd_service_;
   // We keep a ref pointer here just to make sure the service class stays alive
   // long enough.
   scoped_refptr<SafeBrowsingService> sb_service_;
   ClientSideDetectionHost* host_;
 
   DISALLOW_COPY_AND_ASSIGN(ShouldClassifyUrlRequest);
 };
 
 // This class is used to display the phishing interstitial.
@@ skipping 17 matching lines @@
 
   // We're taking care of deleting this object.  No-one else should delete
   // this object.
   virtual ~CsdClient() {}
 
   DISALLOW_COPY_AND_ASSIGN(CsdClient);
 };
 
 // static
 ClientSideDetectionHost* ClientSideDetectionHost::Create(
-    TabContents* tab) {
+    WebContents* tab) {
   return new ClientSideDetectionHost(tab);
 }
 
-ClientSideDetectionHost::ClientSideDetectionHost(TabContents* tab)
+ClientSideDetectionHost::ClientSideDetectionHost(WebContents* tab)
     : content::WebContentsObserver(tab),
       csd_service_(NULL),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       unsafe_unique_page_id_(-1) {
   DCHECK(tab);
   csd_service_ = g_browser_process->safe_browsing_detection_service();
   feature_extractor_.reset(new BrowserFeatureExtractor(tab, csd_service_));
   sb_service_ = g_browser_process->safe_browsing_service();
   // Note: csd_service_ and sb_service_ will be NULL here in testing.
   registrar_.Add(this, content::NOTIFICATION_RESOURCE_RESPONSE_STARTED,
-                 content::Source<RenderViewHostDelegate>(tab));
+                 content::Source<WebContents>(tab));
   if (sb_service_) {
     sb_service_->AddObserver(this);
   }
 }
 
 ClientSideDetectionHost::~ClientSideDetectionHost() {
   if (sb_service_) {
     sb_service_->RemoveObserver(this);
   }
 }
 
 bool ClientSideDetectionHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ClientSideDetectionHost, message)
     IPC_MESSAGE_HANDLER(SafeBrowsingHostMsg_PhishingDetectionDone,
                         OnPhishingDetectionDone)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ClientSideDetectionHost::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
-  // TODO(noelutz): move this DCHECK to TabContents and fix all the unit tests
+  // TODO(noelutz): move this DCHECK to WebContents and fix all the unit tests
   // that don't call this method on the UI thread.
   // DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (details.is_in_page) {
     // If the navigation is within the same page, the user isn't really
     // navigating away.  We don't need to cancel a pending callback or
     // begin a new classification.
     return;
   }
   // If we navigate away and there currently is a pending phishing
   // report request we have to cancel it to make sure we don't display
@@ skipping 16 matching lines @@
   if (params.url.host() != cur_host_) {
     cur_host_ = params.url.host();
     cur_host_redirects_ = params.redirects;
   }
   browse_info_->host_redirects = cur_host_redirects_;
   browse_info_->url_redirects = params.redirects;
   browse_info_->http_status_code = details.http_status_code;
 
   // Notify the renderer if it should classify this URL.
   classification_request_ = new ShouldClassifyUrlRequest(params,
-                                                         tab_contents(),
+                                                         web_contents(),
                                                          csd_service_,
                                                          sb_service_,
                                                          this);
   classification_request_->Start();
 }
 
 void ClientSideDetectionHost::OnSafeBrowsingHit(
     const SafeBrowsingService::UnsafeResource& resource) {
   // Check that this notification is really for us and that it corresponds to
   // either a malware or phishing hit.  In this case we store the unique page
   // ID for later.
-  if (tab_contents() &&
-      tab_contents()->GetRenderProcessHost()->GetID() ==
+  if (web_contents() &&
+      web_contents()->GetRenderProcessHost()->GetID() ==
           resource.render_process_host_id &&
-      tab_contents()->GetRenderViewHost()->routing_id() ==
+      web_contents()->GetRenderViewHost()->routing_id() ==
           resource.render_view_id &&
       (resource.threat_type == SafeBrowsingService::URL_PHISHING ||
        resource.threat_type == SafeBrowsingService::URL_MALWARE) &&
-      tab_contents()->GetController().GetActiveEntry()) {
+      web_contents()->GetController().GetActiveEntry()) {
     unsafe_unique_page_id_ =
-        tab_contents()->GetController().GetActiveEntry()->GetUniqueID();
+        web_contents()->GetController().GetActiveEntry()->GetUniqueID();
     // We also keep the resource around in order to be able to send the
     // malicious URL to the server.
     unsafe_resource_.reset(new SafeBrowsingService::UnsafeResource(resource));
     unsafe_resource_->client = NULL;  // Make sure we don't do anything stupid.
   }
 }
 
 void ClientSideDetectionHost::WebContentsDestroyed(WebContents* tab) {
   DCHECK(tab);
   // Tell any pending classification request that it is being canceled.
@@ skipping 42 matching lines @@
   }
   browse_info_.reset();
 }
 
 void ClientSideDetectionHost::MaybeShowPhishingWarning(GURL phishing_url,
                                                        bool is_phishing) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(2) << "Received server phishing verdict for URL:" << phishing_url
           << " is_phishing:" << is_phishing;
   if (is_phishing) {
-    DCHECK(tab_contents());
+    DCHECK(web_contents());
     if (sb_service_) {
       SafeBrowsingService::UnsafeResource resource;
       resource.url = phishing_url;
       resource.original_url = phishing_url;
       resource.is_subresource = false;
       resource.threat_type = SafeBrowsingService::CLIENT_SIDE_PHISHING_URL;
       resource.render_process_host_id =
-          tab_contents()->GetRenderProcessHost()->GetID();
+          web_contents()->GetRenderProcessHost()->GetID();
       resource.render_view_id =
-          tab_contents()->GetRenderViewHost()->routing_id();
+          web_contents()->GetRenderViewHost()->routing_id();
       if (!sb_service_->IsWhitelisted(resource)) {
         // We need to stop any pending navigations, otherwise the interstital
         // might not get created properly.
-        tab_contents()->GetController().DiscardNonCommittedEntries();
+        web_contents()->GetController().DiscardNonCommittedEntries();
         resource.client = new CsdClient();  // Will delete itself
         sb_service_->DoDisplayBlockingPage(resource);
       }
     }
   }
 }
 
 void ClientSideDetectionHost::FeatureExtractionDone(
     bool success,
     ClientPhishingRequest* request) {
@@ skipping 23 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(type, content::NOTIFICATION_RESOURCE_RESPONSE_STARTED);
   const ResourceRequestDetails* req = content::Details<ResourceRequestDetails>(
       details).ptr();
   if (req && browse_info_.get()) {
     browse_info_->ips.insert(req->socket_address().host());
   }
 }
 
 bool ClientSideDetectionHost::DidShowSBInterstitial() {
-  if (unsafe_unique_page_id_ <= 0 || !tab_contents()) {
+  if (unsafe_unique_page_id_ <= 0 || !web_contents()) {
     return false;
   }
   const NavigationEntry* nav_entry =
-      tab_contents()->GetController().GetActiveEntry();
+      web_contents()->GetController().GetActiveEntry();
   return (nav_entry && nav_entry->GetUniqueID() == unsafe_unique_page_id_);
 }
 
 void ClientSideDetectionHost::set_client_side_detection_service(
     ClientSideDetectionService* service) {
   csd_service_ = service;
 }
 
 void ClientSideDetectionHost::set_safe_browsing_service(
     SafeBrowsingService* service) {
   if (sb_service_) {
     sb_service_->RemoveObserver(this);
   }
   sb_service_ = service;
   if (sb_service_) {
     sb_service_->AddObserver(this);
   }
 }
 
 }  // namespace safe_browsing