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

chrome/browser/tabs/tab_finder.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/tabs/tab_finder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/stl_util.h"
@@ skipping 10 matching lines @@
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "content/public/common/page_transition_types.h"
 
 using content::WebContents;
 
 class TabFinder::WebContentsObserverImpl : public content::WebContentsObserver {
  public:
-  WebContentsObserverImpl(TabContents* tab, TabFinder* finder);
+  WebContentsObserverImpl(WebContents* tab, TabFinder* finder);
   virtual ~WebContentsObserverImpl();
 
-  TabContents* tab_contents() {
-    return content::WebContentsObserver::tab_contents();
+  WebContents* web_contents() {
+    return content::WebContentsObserver::web_contents();
   }
 
   // content::WebContentsObserver overrides:
   virtual void DidNavigateAnyFrame(
       const content::LoadCommittedDetails& details,
       const content::FrameNavigateParams& params) OVERRIDE;
   virtual void WebContentsDestroyed(WebContents* tab) OVERRIDE;
 
  private:
   TabFinder* finder_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsObserverImpl);
 };
 
 TabFinder::WebContentsObserverImpl::WebContentsObserverImpl(
-    TabContents* tab,
+    WebContents* tab,
     TabFinder* finder)
     : content::WebContentsObserver(tab),
       finder_(finder) {
 }
 
 TabFinder::WebContentsObserverImpl::~WebContentsObserverImpl() {
 }
 
 void TabFinder::WebContentsObserverImpl::DidNavigateAnyFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
-  finder_->DidNavigateAnyFrame(tab_contents(), details, params);
+  finder_->DidNavigateAnyFrame(web_contents(), details, params);
 }
 
 void TabFinder::WebContentsObserverImpl::WebContentsDestroyed(
     WebContents* tab) {
   finder_->TabDestroyed(this);
   delete this;
 }
 
 // static
 TabFinder* TabFinder::GetInstance() {
@@ skipping 41 matching lines @@
   return NULL;
 }
 
 void TabFinder::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK_EQ(type, content::NOTIFICATION_TAB_PARENTED);
 
   // The tab was added to a browser. Query for its state now.
   TabContentsWrapper* tab = content::Source<TabContentsWrapper>(source).ptr();
-  TrackTab(tab->tab_contents());
+  TrackTab(tab->web_contents());
 }
 
 TabFinder::TabFinder() {
   registrar_.Add(this, content::NOTIFICATION_TAB_PARENTED,
                  content::NotificationService::AllSources());
 }
 
 TabFinder::~TabFinder() {
   STLDeleteElements(&tab_contents_observers_);
 }
 
 void TabFinder::DidNavigateAnyFrame(
-    TabContents* source,
+    WebContents* source,
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   CancelRequestsFor(source);
 
   if (content::PageTransitionIsRedirect(params.transition)) {
     // If this is a redirect, we need to go to the db to get the start.
     FetchRedirectStart(source);
   } else if (params.redirects.size() > 1 ||
              params.redirects[0] != details.entry->GetURL()) {
-    tab_contents_to_url_[source] = params.redirects[0];
+    web_contents_to_url_[source] = params.redirects[0];
   }
 }
 
-bool TabFinder::TabMatchesURL(TabContents* tab_contents, const GURL& url) {
+bool TabFinder::TabMatchesURL(WebContents* tab_contents, const GURL& url) {
   if (tab_contents->GetURL() == url)
     return true;
 
-  TabContentsToURLMap::const_iterator i =
-      tab_contents_to_url_.find(tab_contents);
-  return i != tab_contents_to_url_.end() && i->second == url;
+  WebContentsToURLMap::const_iterator i =
+      web_contents_to_url_.find(tab_contents);
+  return i != web_contents_to_url_.end() && i->second == url;
 }
 
 TabContents* TabFinder::FindTabInBrowser(Browser* browser, const GURL& url) {
   if (!browser->is_type_tabbed())
     return NULL;
 
   for (int i = 0; i < browser->tab_count(); ++i) {
     if (TabMatchesURL(browser->GetTabContentsAt(i), url))
       return browser->GetTabContentsAt(i);
   }
   return NULL;
 }
 
-void TabFinder::TrackTab(TabContents* tab) {
+void TabFinder::TrackTab(WebContents* tab) {
   for (WebContentsObservers::const_iterator i = tab_contents_observers_.begin();
        i != tab_contents_observers_.end(); ++i) {
-    if ((*i)->tab_contents() == tab) {
+    if ((*i)->web_contents() == tab) {
       // Already tracking the tab.
       return;
     }
   }
   WebContentsObserverImpl* observer = new WebContentsObserverImpl(tab, this);
   tab_contents_observers_.insert(observer);
   FetchRedirectStart(tab);
 }
 
 void TabFinder::TabDestroyed(WebContentsObserverImpl* observer) {
   DCHECK_GT(tab_contents_observers_.count(observer), 0u);
   tab_contents_observers_.erase(observer);
 }
 
-void TabFinder::CancelRequestsFor(TabContents* tab_contents) {
+void TabFinder::CancelRequestsFor(WebContents* web_contents) {
   Profile* profile =
-      Profile::FromBrowserContext(tab_contents->GetBrowserContext());
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
   if (profile->IsOffTheRecord())
     return;
 
-  tab_contents_to_url_.erase(tab_contents);
+  web_contents_to_url_.erase(web_contents);
 
   HistoryService* history = profile->GetHistoryService(
       Profile::EXPLICIT_ACCESS);
   if (history) {
     CancelableRequestProvider::Handle request_handle;
-    if (callback_consumer_.GetFirstHandleForClientData(tab_contents,
+    if (callback_consumer_.GetFirstHandleForClientData(web_contents,
                                                        &request_handle)) {
       history->CancelRequest(request_handle);
     }
   }
 }
 
-void TabFinder::FetchRedirectStart(TabContents* tab) {
+void TabFinder::FetchRedirectStart(WebContents* tab) {
   Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
   if (profile->IsOffTheRecord())
     return;
 
   NavigationEntry* committed_entry =
       tab->GetController().GetLastCommittedEntry();
   if (!committed_entry || committed_entry->GetURL().is_empty())
     return;
 
   HistoryService* history = profile->GetHistoryService(
       Profile::EXPLICIT_ACCESS);
   if (history) {
     CancelableRequestProvider::Handle request_handle =
         history->QueryRedirectsTo(
             committed_entry->GetURL(),
             &callback_consumer_,
             base::Bind(&TabFinder::QueryRedirectsToComplete,
                        base::Unretained(this)));
     callback_consumer_.SetClientData(history, request_handle, tab);
   }
 }
 
 void TabFinder::QueryRedirectsToComplete(HistoryService::Handle handle,
                                          GURL url,
                                          bool success,
                                          history::RedirectList* redirects) {
   if (success && !redirects->empty()) {
-    TabContents* tab_contents =
+    WebContents* web_contents =
         callback_consumer_.GetClientDataForCurrentRequest();
-    DCHECK(tab_contents);
-    tab_contents_to_url_[tab_contents] = redirects->back();
+    DCHECK(web_contents);
+    web_contents_to_url_[web_contents] = redirects->back();
   }
 }