TabContents -> WebContentsImpl, part 21.

chrome/browser/ui/browser.cc

 // Copyright (c) 2012 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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 833 matching lines @@
       extension_misc::LAUNCH_WINDOW,
       url,
       &app_browser);
 
   if (!tab)
     return NULL;
 
   if (update_shortcut) {
     // Set UPDATE_SHORTCUT as the pending web app action. This action is picked
     // up in LoadingStateChanged to schedule a GetApplicationInfo. And when
-    // the web app info is available, TabContents notifies Browser via
+    // the web app info is available, ExtensionTabHelper notifies Browser via
     // OnDidGetApplicationInfo, which calls
     // web_app::UpdateShortcutForTabContents when it sees UPDATE_SHORTCUT as
     // pending web app action.
     app_browser->pending_web_app_action_ = UPDATE_SHORTCUT;
   }
   return tab;
 }
 
 // static
 WebContents* Browser::OpenApplicationTab(Profile* profile,
@@ skipping 1906 matching lines @@
   prefs->RegisterIntegerPref(prefs::kDiskCacheSize,
                              0,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kMediaCacheSize,
                              0,
                              PrefService::UNSYNCABLE_PREF);
 }
 
 // static
 bool Browser::RunUnloadEventsHelper(WebContents* contents) {
-  // If the TabContents is not connected yet, then there's no unload
-  // handler we can fire even if the TabContents has an unload listener.
+  // If the WebContents is not connected yet, then there's no unload
+  // handler we can fire even if the WebContents has an unload listener.
   // One case where we hit this is in a tab that has an infinite loop
   // before load.
   if (contents->NeedToFireBeforeUnload()) {
     // If the page has unload listeners, then we tell the renderer to fire
     // them. Once they have fired, we'll get a message back saying whether
     // to proceed closing the page or not, which sends us back to this method
     // with the NeedToFireBeforeUnload bit cleared.
     contents->GetRenderViewHost()->FirePageBeforeUnload(false);
     return true;
   }
@@ skipping 479 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelDelegate implementation:
 
 TabContentsWrapper* Browser::AddBlankTab(bool foreground) {
   return AddBlankTabAt(-1, foreground);
 }
 
 TabContentsWrapper* Browser::AddBlankTabAt(int index, bool foreground) {
   // Time new tab page creation time.  We keep track of the timing data in
-  // TabContents, but we want to include the time it takes to create the
-  // TabContents object too.
+  // WebContents, but we want to include the time it takes to create the
+  // WebContents object too.
   base::TimeTicks new_tab_start_time = base::TimeTicks::Now();
   browser::NavigateParams params(this, GURL(chrome::kChromeUINewTabURL),
                                  content::PAGE_TRANSITION_TYPED);
   params.disposition = foreground ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
   params.tabstrip_index = index;
   browser::Navigate(&params);
   params.target_contents->web_contents()->SetNewTabStartTime(
       new_tab_start_time);
   return params.target_contents;
 }
@@ skipping 80 matching lines @@
           Browser::CreateParams(TYPE_POPUP, profile_));
     }
 
     // Preserve the size of the original window. The new window has already
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = browser->window();
     new_window->SetBounds(gfx::Rect(new_window->GetRestoredBounds().origin(),
                           window()->GetRestoredBounds().size()));
 
     // We need to show the browser now.  Otherwise ContainerWin assumes the
-    // TabContents is invisible and won't size it.
+    // WebContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
     browser->AddTab(contents_dupe, content::PAGE_TRANSITION_LINK);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(contents_dupe, pinned);
@@ skipping 112 matching lines @@
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
                            TabContentsWrapper* contents,
                            int index) {
   fullscreen_controller_->OnTabClosing(contents->web_contents());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_CLOSING,
       content::Source<NavigationController>(
           &contents->web_contents()->GetController()),
       content::NotificationService::NoDetails());
 
-  // Sever the TabContents' connection back to us.
+  // Sever the WebContents' connection back to us.
   SetAsDelegate(contents, NULL);
 }
 
 void Browser::TabDetachedAt(TabContentsWrapper* contents, int index) {
   TabDetachedAtImpl(contents, index, DETACH_TYPE_DETACH);
 }
 
 void Browser::TabDeactivated(TabContentsWrapper* contents) {
   fullscreen_controller_->OnTabDeactivated(contents);
   if (instant())
@@ skipping 579 matching lines @@
 
   return true;
 }
 
 void Browser::WebContentsCreated(WebContents* source_contents,
                                  int64 source_frame_id,
                                  const GURL& target_url,
                                  WebContents* new_contents) {
   // Create a TabContentsWrapper now, so all observers are in place, as the
   // network requests for its initial navigation will start immediately. The
-  // TabContents will later be inserted into this browser using
+  // WebContents will later be inserted into this browser using
   // Browser::Navigate via AddNewContents. The latter will retrieve the newly
-  // created TabContentsWrapper from TabContents object.
+  // created TabContentsWrapper from WebContents object.
   new TabContentsWrapper(new_contents);
 
   // Notify.
   RetargetingDetails details;
   details.source_web_contents = source_contents;
   details.source_frame_id = source_frame_id;
   details.target_url = target_url;
   details.target_web_contents = new_contents;
   details.not_yet_in_tabstrip = true;
   content::NotificationService::current()->Notify(
@@ skipping 1249 matching lines @@
 
 // static
 Browser* Browser::GetOrCreateTabbedBrowser(Profile* profile) {
   Browser* browser = GetTabbedBrowser(profile, false);
   if (!browser)
     browser = Browser::Create(profile);
   return browser;
 }
 
 void Browser::SetAsDelegate(TabContentsWrapper* tab, Browser* delegate) {
-  // TabContents...
+  // WebContents...
   tab->web_contents()->SetDelegate(delegate);
 
   // ...and all the helpers.
   tab->blocked_content_tab_helper()->set_delegate(delegate);
   tab->bookmark_tab_helper()->set_delegate(delegate);
   tab->constrained_window_tab_helper()->set_delegate(delegate);
   tab->core_tab_helper()->set_delegate(delegate);
   tab->extension_tab_helper()->set_delegate(delegate);
   tab->search_engine_tab_helper()->set_delegate(delegate);
 }
@@ skipping 77 matching lines @@
 
 void Browser::TabRestoreServiceDestroyed(TabRestoreService* service) {
   if (!tab_restore_service_)
     return;
 
   DCHECK_EQ(tab_restore_service_, service);
   tab_restore_service_->RemoveObserver(this);
   tab_restore_service_ = NULL;
 }
 
-// Centralized method for creating a TabContents, configuring and installing
-// all its supporting objects and observers.
+// Centralized method for creating a TabContentsWrapper, configuring and
+// installing all its supporting objects and observers.
 TabContentsWrapper* Browser::TabContentsFactory(
     Profile* profile,
     SiteInstance* site_instance,
     int routing_id,
     const WebContents* base_web_contents,
     content::SessionStorageNamespace* session_storage_namespace) {
   WebContents* new_contents = WebContents::Create(
       profile, site_instance, routing_id, base_web_contents,
       session_storage_namespace);
   TabContentsWrapper* wrapper = new TabContentsWrapper(new_contents);
@@ skipping 100 matching lines @@
     Browser* browser = Browser::CreateWithParams(
         Browser::CreateParams(TYPE_TABBED, profile_));
 
     // Preserve the size of the original window. The new window has already
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = browser->window();
     new_window->SetBounds(gfx::Rect(new_window->GetRestoredBounds().origin(),
                           window()->GetRestoredBounds().size()));
 
     // We need to show the browser now. Otherwise ContainerWin assumes the
-    // TabContents is invisible and won't size it.
+    // WebContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
     browser->AddTab(view_source_contents, content::PAGE_TRANSITION_LINK);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(view_source_contents, false);
@@ skipping 70 matching lines @@
     ShowSingletonTabOverwritingNTP(params);
   } else {
     LoginUIServiceFactory::GetForProfile(
         profile()->GetOriginalProfile())->ShowLoginUI(false);
   }
 }
 
 void Browser::ToggleSpeechInput() {
   GetSelectedWebContents()->GetRenderViewHost()->ToggleSpeechInput();
 }