chrome: Put browser_navigator.h into chrome namespace.

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"
@@ skipping 49 matching lines @@
   Browser* browser = browser::FindTabbedBrowser(profile, false);
   return browser ? browser : Browser::Create(profile);
 }
 
 // Change some of the navigation parameters based on the particular URL.
 // Currently this applies to some chrome:// pages which we always want to open
 // in a non-incognito window. Note that even though a ChromeOS guest session is
 // technically an incognito window, these URLs are allowed.
 // Returns true on success. Otherwise, if changing params leads the browser into
 // an erroneous state, returns false.
-bool AdjustNavigateParamsForURL(browser::NavigateParams* params) {
+bool AdjustNavigateParamsForURL(chrome::NavigateParams* params) {
   if (params->target_contents != NULL ||
-      browser::IsURLAllowedInIncognito(params->url) ||
+      chrome::IsURLAllowedInIncognito(params->url) ||
       Profile::IsGuestSession()) {
     return true;
   }
 
   Profile* profile =
       params->browser ? params->browser->profile() : params->profile;
 
   if (profile->IsOffTheRecord() || params->disposition == OFF_THE_RECORD) {
     profile = profile->GetOriginalProfile();
 
     // If incognito is forced, we punt.
     PrefService* prefs = profile->GetPrefs();
     if (prefs && IncognitoModePrefs::GetAvailability(prefs) ==
             IncognitoModePrefs::FORCED) {
       return false;
     }
 
     params->disposition = SINGLETON_TAB;
     params->profile = profile;
     params->browser = browser::FindOrCreateTabbedBrowser(profile);
-    params->window_action = browser::NavigateParams::SHOW_WINDOW;
+    params->window_action = chrome::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) {
+Browser* GetBrowserForDisposition(chrome::NavigateParams* params) {
   // 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 = chrome::GetActiveTabContents(params->browser);
 
   Profile* profile =
       params->browser ? params->browser->profile() : params->profile;
 
@@ skipping 63 matching lines @@
     case IGNORE_ACTION:
       return NULL;
     default:
       NOTREACHED();
   }
   return NULL;
 }
 
 // Fix disposition and other parameter values depending on prevailing
 // conditions.
-void NormalizeDisposition(browser::NavigateParams* params) {
+void NormalizeDisposition(chrome::NavigateParams* params) {
   // Calculate the WindowOpenDisposition if necessary.
   if (params->browser->tab_strip_model()->empty() &&
       (params->disposition == NEW_BACKGROUND_TAB ||
        params->disposition == CURRENT_TAB ||
        params->disposition == SINGLETON_TAB)) {
     params->disposition = NEW_FOREGROUND_TAB;
   }
   if (params->browser->profile()->IsOffTheRecord() &&
       params->disposition == OFF_THE_RECORD) {
     params->disposition = NEW_FOREGROUND_TAB;
   }
   if (!params->source_contents && params->disposition == CURRENT_TAB)
     params->disposition = NEW_FOREGROUND_TAB;
 
   switch (params->disposition) {
     case NEW_BACKGROUND_TAB:
       // Disposition trumps add types. ADD_ACTIVE is a default, so we need to
       // remove it if disposition implies the tab is going to open in the
       // background.
       params->tabstrip_add_types &= ~TabStripModel::ADD_ACTIVE;
       break;
 
     case NEW_WINDOW:
     case NEW_POPUP:
       // Code that wants to open a new window typically expects it to be shown
       // automatically.
-      if (params->window_action == browser::NavigateParams::NO_ACTION)
-        params->window_action = browser::NavigateParams::SHOW_WINDOW;
+      if (params->window_action == chrome::NavigateParams::NO_ACTION)
+        params->window_action = chrome::NavigateParams::SHOW_WINDOW;
       // Fall-through.
     case NEW_FOREGROUND_TAB:
     case SINGLETON_TAB:
       params->tabstrip_add_types |= TabStripModel::ADD_ACTIVE;
       break;
 
     default:
       break;
   }
 }
 
 // Obtain the profile used by the code that originated the Navigate() request.
 // |source_browser| represents the Browser that was supplied in |params| before
 // it was modified.
-Profile* GetSourceProfile(browser::NavigateParams* params,
-    Browser* source_browser) {
+Profile* GetSourceProfile(chrome::NavigateParams* params,
+                          Browser* source_browser) {
   if (params->source_contents)
     return params->source_contents->profile();
 
   if (source_browser)
     return source_browser->profile();
 
   if (params->profile)
     return params->profile;
 
   // We couldn't find one in any of the source metadata, so we'll fall back to
   // the profile associated with the target browser.
   return params->browser->profile();
 }
 
 void LoadURLInContents(WebContents* target_contents,
                        const GURL& url,
-                       browser::NavigateParams* params,
+                       chrome::NavigateParams* params,
                        const std::string& extra_headers) {
   if (params->transferred_global_request_id != GlobalRequestID()) {
     target_contents->GetController().TransferURL(
         url,
         params->referrer,
         params->transition, extra_headers,
         params->transferred_global_request_id,
         params->is_renderer_initiated);
   } else if (params->is_renderer_initiated) {
     target_contents->GetController().LoadURLFromRenderer(
         url,
         params->referrer,
         params->transition,  extra_headers);
   } else {
     target_contents->GetController().LoadURL(
         url,
         params->referrer,
         params->transition,  extra_headers);
   }
 
 }
 
 // This class makes sure the Browser object held in |params| is made visible
 // by the time it goes out of scope, provided |params| wants it to be shown.
 class ScopedBrowserDisplayer {
  public:
-  explicit ScopedBrowserDisplayer(browser::NavigateParams* params)
+  explicit ScopedBrowserDisplayer(chrome::NavigateParams* params)
       : params_(params) {
   }
   ~ScopedBrowserDisplayer() {
-    if (params_->window_action == browser::NavigateParams::SHOW_WINDOW_INACTIVE)
+    if (params_->window_action == chrome::NavigateParams::SHOW_WINDOW_INACTIVE)
       params_->browser->window()->ShowInactive();
-    else if (params_->window_action == browser::NavigateParams::SHOW_WINDOW)
+    else if (params_->window_action == chrome::NavigateParams::SHOW_WINDOW)
       params_->browser->window()->Show();
   }
  private:
-  browser::NavigateParams* params_;
+  chrome::NavigateParams* params_;
   DISALLOW_COPY_AND_ASSIGN(ScopedBrowserDisplayer);
 };
 
 // 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
 // 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 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)
+  explicit ScopedTargetContentsOwner(chrome::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.
   TabContents* ReleaseOwnership() {
     return target_contents_owner_.release();
   }
 
  private:
-  browser::NavigateParams* params_;
+  chrome::NavigateParams* params_;
   scoped_ptr<TabContents> target_contents_owner_;
   DISALLOW_COPY_AND_ASSIGN(ScopedTargetContentsOwner);
 };
 
-void InitializeExtraHeaders(browser::NavigateParams* params,
+void InitializeExtraHeaders(chrome::NavigateParams* params,
                             Profile* profile,
                             std::string* extra_headers) {
 #if defined(ENABLE_RLZ)
   if (!profile)
     profile = params->profile;
 
   // If this is a home page navigation, check to see if the home page is
   // set to Google and add RLZ HTTP headers to the request.  This is only
   // done if Google was the original home page, and not changed afterwards by
   // the user.
@@ skipping 24 matching lines @@
   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
 
-namespace browser {
+namespace chrome {
 
-NavigateParams::NavigateParams(
-    Browser* a_browser,
-    const GURL& a_url,
-    content::PageTransition a_transition)
+NavigateParams::NavigateParams(Browser* a_browser,
+                               const GURL& a_url,
+                               content::PageTransition a_transition)
     : url(a_url),
       target_contents(NULL),
       source_contents(NULL),
       disposition(CURRENT_TAB),
       transition(a_transition),
       is_renderer_initiated(false),
       tabstrip_index(-1),
       tabstrip_add_types(TabStripModel::ADD_ACTIVE),
       window_action(NO_ACTION),
       user_gesture(true),
@@ skipping 64 matching lines @@
   ScopedBrowserDisplayer displayer(params);
 
   // 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 &&
+  if (params->window_action == NavigateParams::NO_ACTION &&
       source_browser != params->browser &&
       params->browser->tab_strip_model()->empty()) {
-    params->window_action = browser::NavigateParams::SHOW_WINDOW;
+    params->window_action = 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 &&
+  if (params->window_action == NavigateParams::SHOW_WINDOW &&
       params->disposition == NEW_POPUP &&
       params->user_gesture == false) {
-    params->window_action = browser::NavigateParams::SHOW_WINDOW_INACTIVE;
+    params->window_action = NavigateParams::SHOW_WINDOW_INACTIVE;
   }
 
   // Determine if the navigation was user initiated. If it was, we need to
   // 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 ||
@@ skipping 139 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
+}  // namespace chrome