When the user navigates to the home page, make sure to set the RLZ string

chrome/browser/ui/browser_navigator.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/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/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.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/web_applications/web_app.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_url_handler.h"
 #include "content/browser/site_instance.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "net/http/http_util.h"
 
 namespace {
 
 // Returns true if the specified Browser can open tabs. Not all Browsers support
 // multiple tabs, such as app frames and popups. This function returns false for
 // those types of Browser.
 bool WindowCanOpenTabs(Browser* browser) {
   return browser->CanSupportWindowFeature(Browser::FEATURE_TABSTRIP) ||
       browser->tabstrip_model()->empty();
 }
@@ skipping 230 matching lines @@
   TabContentsWrapper* ReleaseOwnership() {
     return target_contents_owner_.release();
   }
 
  private:
   browser::NavigateParams* params_;
   scoped_ptr<TabContentsWrapper> target_contents_owner_;
   DISALLOW_COPY_AND_ASSIGN(ScopedTargetContentsOwner);
 };
 
+void InitializeExtraHeaders(browser::NavigateParams* params,
+                            Profile* profile,
+                            std::string* extra_headers) {
+#if defined(GOOGLE_CHROME_BUILD)
+  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.
+  if (profile && (params->transition & PageTransition::HOME_PAGE) != 0) {
+    PrefService* pref_service = profile->GetPrefs();
+    if (pref_service) {
+      if (!pref_service->GetBoolean(prefs::kHomePageChanged)) {
+        std::string homepage = pref_service->GetString(prefs::kHomePage);
+        if (homepage == GoogleURLTracker::kDefaultGoogleHomepage) {
+          std::wstring rlz_string;
+          RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, &rlz_string);
+          if (!rlz_string.empty()) {
+            // DO NOT COMMIT: waiting for the search folks to tell me the
+            // actual HTTP header name they want to see.
+            net::HttpUtil::AppendHeaderIfMissing("X-Google-Rlz",
+                                                 WideToUTF8(rlz_string),
+                                                 extra_headers);
+          }
+        }
+      }
+    }
+  }
+#endif
+}
+
 }  // namespace
 
 namespace browser {
 
 NavigateParams::NavigateParams(
     Browser* a_browser,
     const GURL& a_url,
     PageTransition::Type a_transition)
     : url(a_url),
       target_contents(NULL),
@@ skipping 82 matching lines @@
   PageTransition::Type base_transition =
       PageTransition::StripQualifier(params->transition);
   bool user_initiated = params->transition & PageTransition::FROM_ADDRESS_BAR ||
       base_transition == PageTransition::TYPED ||
       base_transition == PageTransition::AUTO_BOOKMARK ||
       base_transition == PageTransition::GENERATED ||
       base_transition == PageTransition::START_PAGE ||
       base_transition == PageTransition::RELOAD ||
       base_transition == PageTransition::KEYWORD;
 
+  std::string extra_headers;
+
   // Check if this is a singleton tab that already exists
   int singleton_index = GetIndexOfSingletonTab(params);
 
   // 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 = params->url.is_empty() ? params->browser->GetHomePage()
-                                      : params->url;
+    GURL url;
+    if (params->url.is_empty()) {
+      url = params->browser->GetHomePage();
+      params->transition |= PageTransition::HOME_PAGE;
+    } else {
+      url = params->url;
+    }
+
     if (params->disposition != CURRENT_TAB) {
       TabContents* source_contents = params->source_contents ?
           params->source_contents->tab_contents() : NULL;
       params->target_contents =
           Browser::TabContentsFactory(
               params->browser->profile(),
               tab_util::GetSiteInstanceForNewTab(
                   source_contents, params->browser->profile(), url),
               MSG_ROUTING_NONE,
               source_contents,
@@ skipping 16 matching lines @@
       // same as the source.
       params->target_contents = params->source_contents;
       DCHECK(params->target_contents);
     }
 
     if (user_initiated) {
       static_cast<RenderViewHostDelegate*>(params->target_contents->
           tab_contents())->OnUserGesture();
     }
 
+    InitializeExtraHeaders(params, params->target_contents->profile(),
+                           &extra_headers);
+
     // Try to handle non-navigational URLs that popup dialogs and such, these
     // should not actually navigate.
     if (!HandleNonNavigationAboutURL(url)) {
       // Perform the actual navigation.
-      params->target_contents->controller().LoadURL(url, params->referrer,
-                                                    params->transition);
+      params->target_contents->controller().LoadURLWithHeaders(
+          url, params->referrer, params->transition, extra_headers);
     }
   } else {
     // |target_contents| was specified non-NULL, and so we assume it has already
     // been navigated appropriately. We need to do nothing more other than
     // add it to the appropriate tabstrip.
   }
 
   // If the user navigated from the omnibox, and the selected tab is going to
   // lose focus, then make sure the focus for the source tab goes away from the
   // omnibox.
@@ skipping 26 matching lines @@
     target_contents_owner.ReleaseOwnership();
   }
 
   if (singleton_index >= 0) {
     TabContents* target = params->browser->GetTabContentsAt(singleton_index);
 
     if (target->is_crashed()) {
       target->controller().Reload(true);
     } else if (params->path_behavior == NavigateParams::IGNORE_AND_NAVIGATE &&
         target->GetURL() != params->url) {
-      target->controller().LoadURL(
-          params->url, params->referrer, params->transition);
+      InitializeExtraHeaders(params, NULL, &extra_headers);
+      target->controller().LoadURLWithHeaders(
+          params->url, params->referrer, params->transition, extra_headers);
     }
 
     // If the singleton tab isn't already selected, select it.
     if (params->source_contents != params->target_contents)
       params->browser->ActivateTabAt(singleton_index, user_initiated);
   }
 }
 
 // Returns the index of an existing singleton tab in |params->browser| matching
 // the URL specified in |params|.
@@ skipping 34 matching lines @@
                                     rewritten_url, replacements)) {
       params->target_contents = tab;
       return tab_index;
     }
   }
 
   return -1;
 }
 
 }  // namespace browser