TabContentsWrapper -> TabContents, part 53.

chrome/browser/ui/browser_navigator.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_navigator.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_about_handler.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/google/google_url_tracker.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/status_bubble.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_url_handler.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 64 matching lines @@
     params->window_action = browser::NavigateParams::SHOW_WINDOW;
   }
 
   return true;
 }
 
 // Returns a Browser that can host the navigation or tab addition specified in
 // |params|. This might just return the same Browser specified in |params|, or
 // some other if that Browser is deemed incompatible.
 Browser* GetBrowserForDisposition(browser::NavigateParams* params) {
-  // If no source TabContentsWrapper was specified, we use the selected one from
+  // If no source TabContents was specified, we use the selected one from
   // the target browser. This must happen first, before
   // GetBrowserForDisposition() has a chance to replace |params->browser| with
   // another one.
   if (!params->source_contents && params->browser)
     params->source_contents =
-        params->browser->GetSelectedTabContentsWrapper();
+        params->browser->GetActiveTabContents();
 
   Profile* profile =
       params->browser ? params->browser->profile() : params->profile;
 
   switch (params->disposition) {
     case CURRENT_TAB:
       if (!params->browser && profile) {
         // We specified a profile instead of a browser; find or create one.
         params->browser = browser::FindOrCreateTabbedBrowser(profile);
       }
@@ skipping 159 matching lines @@
     if (params_->window_action == browser::NavigateParams::SHOW_WINDOW_INACTIVE)
       params_->browser->window()->ShowInactive();
     else if (params_->window_action == browser::NavigateParams::SHOW_WINDOW)
       params_->browser->window()->Show();
   }
  private:
   browser::NavigateParams* params_;
   DISALLOW_COPY_AND_ASSIGN(ScopedBrowserDisplayer);
 };
 
-// This class manages the lifetime of a TabContentsWrapper created by the
-// Navigate() function. When Navigate() creates a TabContentsWrapper for a URL,
+// This class manages the lifetime of a TabContents created by the
+// Navigate() function. When Navigate() creates a TabContents for a URL,
 // an instance of this class takes ownership of it via TakeOwnership() until the
-// TabContentsWrapper is added to a tab strip at which time ownership is
+// TabContents is added to a tab strip at which time ownership is
 // relinquished via ReleaseOwnership(). If this object goes out of scope without
-// being added to a tab strip, the created TabContentsWrapper is deleted to
+// being added to a tab strip, the created TabContents is deleted to
 // avoid a leak and the params->target_contents field is set to NULL.
 class ScopedTargetContentsOwner {
  public:
   explicit ScopedTargetContentsOwner(browser::NavigateParams* params)
       : params_(params) {
   }
   ~ScopedTargetContentsOwner() {
     if (target_contents_owner_.get())
       params_->target_contents = NULL;
   }
 
   // Assumes ownership of |params_|' target_contents until ReleaseOwnership
   // is called.
   void TakeOwnership() {
     target_contents_owner_.reset(params_->target_contents);
   }
 
   // Relinquishes ownership of |params_|' target_contents.
-  TabContentsWrapper* ReleaseOwnership() {
+  TabContents* ReleaseOwnership() {
     return target_contents_owner_.release();
   }
 
  private:
   browser::NavigateParams* params_;
-  scoped_ptr<TabContentsWrapper> target_contents_owner_;
+  scoped_ptr<TabContents> target_contents_owner_;
   DISALLOW_COPY_AND_ASSIGN(ScopedTargetContentsOwner);
 };
 
 void InitializeExtraHeaders(browser::NavigateParams* params,
                             Profile* profile,
                             std::string* extra_headers) {
 #if defined(ENABLE_RLZ)
   if (!profile)
     profile = params->profile;
 
@@ skipping 17 matching lines @@
           }
         }
       }
     }
   }
 #endif
 }
 
 // If a prerendered page exists for |url|, replace the page at |target_contents|
 // with it.
-bool SwapInPrerender(TabContentsWrapper* target_contents, const GURL& url) {
+bool SwapInPrerender(TabContents* target_contents, const GURL& url) {
   prerender::PrerenderManager* prerender_manager =
       prerender::PrerenderManagerFactory::GetForProfile(
           target_contents->profile());
   WebContents* web_contents = target_contents->web_contents();
   return prerender_manager &&
       prerender_manager->MaybeUsePrerenderedPage(web_contents, url);
 }
 
 }  // namespace
 
@@ skipping 13 matching lines @@
       tabstrip_add_types(TabStripModel::ADD_ACTIVE),
       window_action(NO_ACTION),
       user_gesture(true),
       path_behavior(RESPECT),
       ref_behavior(IGNORE_REF),
       browser(a_browser),
       profile(NULL) {
 }
 
 NavigateParams::NavigateParams(Browser* a_browser,
-                               TabContentsWrapper* a_target_contents)
+                               TabContents* a_target_contents)
     : target_contents(a_target_contents),
       source_contents(NULL),
       disposition(CURRENT_TAB),
       transition(content::PAGE_TRANSITION_LINK),
       is_renderer_initiated(false),
       tabstrip_index(-1),
       tabstrip_add_types(TabStripModel::ADD_ACTIVE),
       window_action(NO_ACTION),
       user_gesture(true),
       path_behavior(RESPECT),
@@ skipping 38 matching lines @@
   if (GetSourceProfile(params, source_browser) != params->browser->profile()) {
     // A tab is being opened from a link from a different profile, we must reset
     // source information that may cause state to be shared.
     params->source_contents = NULL;
     params->referrer = content::Referrer();
   }
 
   // Make sure the Browser is shown if params call for it.
   ScopedBrowserDisplayer displayer(params);
 
-  // Makes sure any TabContentsWrapper created by this function is destroyed if
+  // Makes sure any TabContents created by this function is destroyed if
   // not properly added to a tab strip.
   ScopedTargetContentsOwner target_contents_owner(params);
 
   // Some dispositions need coercion to base types.
   NormalizeDisposition(params);
 
   // If a new window has been created, it needs to be displayed.
   if (params->window_action == browser::NavigateParams::NO_ACTION &&
       source_browser != params->browser &&
       params->browser->tab_strip_model()->empty()) {
     params->window_action = browser::NavigateParams::SHOW_WINDOW;
   }
 
   // If we create a popup window from a non user-gesture, don't activate it.
   if (params->window_action == browser::NavigateParams::SHOW_WINDOW &&
       params->disposition == NEW_POPUP &&
       params->user_gesture == false) {
     params->window_action = browser::NavigateParams::SHOW_WINDOW_INACTIVE;
   }
 
   // Determine if the navigation was user initiated. If it was, we need to
-  // inform the target TabContentsWrapper, and we may need to update the UI.
+  // inform the target TabContents, and we may need to update the UI.
   content::PageTransition base_transition =
       content::PageTransitionStripQualifier(params->transition);
   bool user_initiated =
       params->transition & content::PAGE_TRANSITION_FROM_ADDRESS_BAR ||
       base_transition == content::PAGE_TRANSITION_TYPED ||
       base_transition == content::PAGE_TRANSITION_AUTO_BOOKMARK ||
       base_transition == content::PAGE_TRANSITION_GENERATED ||
       base_transition == content::PAGE_TRANSITION_START_PAGE ||
       base_transition == content::PAGE_TRANSITION_RELOAD ||
       base_transition == content::PAGE_TRANSITION_KEYWORD;
 
   std::string extra_headers;
 
   // Check if this is a singleton tab that already exists
   int singleton_index = GetIndexOfSingletonTab(params);
 
-  // If no target TabContentsWrapper was specified, we need to construct one if
+  // If no target TabContents was specified, we need to construct one if
   // we are supposed to target a new tab; unless it's a singleton that already
   // exists.
   if (!params->target_contents && singleton_index < 0) {
     GURL url;
     if (params->url.is_empty()) {
       url = params->browser->profile()->GetHomePage();
       params->transition = content::PageTransitionFromInt(
           params->transition | content::PAGE_TRANSITION_HOME_PAGE);
     } else {
       url = params->url;
@@ skipping 124 matching lines @@
   content::BrowserURLHandler::GetInstance()->RewriteURLIfNecessary(
       &rewritten_url,
       params->browser->profile(),
       &reverse_on_redirect);
 
   // If there are several matches: prefer the active tab by starting there.
   int start_index = std::max(0, params->browser->active_index());
   int tab_count = params->browser->tab_count();
   for (int i = 0; i < tab_count; ++i) {
     int tab_index = (start_index + i) % tab_count;
-    TabContentsWrapper* tab =
-        params->browser->GetTabContentsWrapperAt(tab_index);
+    TabContents* tab = params->browser->GetTabContentsAt(tab_index);
 
     url_canon::Replacements<char> replacements;
     if (params->ref_behavior == browser::NavigateParams::IGNORE_REF)
       replacements.ClearRef();
     if (params->path_behavior == browser::NavigateParams::IGNORE_AND_NAVIGATE ||
         params->path_behavior == browser::NavigateParams::IGNORE_AND_STAY_PUT) {
       replacements.ClearPath();
       replacements.ClearQuery();
     }
 
@@ skipping 17 matching lines @@
   return !(url.scheme() == chrome::kChromeUIScheme &&
       (url.host() == chrome::kChromeUISettingsHost ||
        url.host() == chrome::kChromeUISettingsFrameHost ||
        url.host() == chrome::kChromeUIExtensionsHost ||
        url.host() == chrome::kChromeUIBookmarksHost ||
        url.host() == chrome::kChromeUISyncPromoHost ||
        url.host() == chrome::kChromeUIUberHost));
 }
 
 }  // namespace browser