Plumb the referrer throughout the OpenURL APIs....

chrome/browser/browser.cc

 // Copyright (c) 2006-2008 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/browser.h"
 
 #include <windows.h>
 #include <shellapi.h>
 
 #include "base/command_line.h"
@@ skipping 504 matching lines @@
     // We don't need to process INVALIDATE_STATE, since that's not visible.
   }
 
   scheduled_updates_.clear();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabContentsDelegate
 
 void Browser::OpenURLFromTab(TabContents* source,
-                             const GURL& url,
+                             const GURL& url, const GURL& referrer,
                              WindowOpenDisposition disposition,
                              PageTransition::Type transition) {
   // No code for these yet
   DCHECK((disposition != NEW_POPUP) && (disposition != SAVE_TO_DISK));
 
   TabContents* current_tab = source ? source : GetSelectedTabContents();
   bool source_tab_was_frontmost = (current_tab == GetSelectedTabContents());
   TabContents* new_contents = NULL;
 
   // If the URL is part of the same web site, then load it in the same
@@ skipping 28 matching lines @@
     }
 
     Browser* b = GetOrCreateTabbedBrowser();
     DCHECK(b);
 
     // If we have just created a new browser window, make sure we select the
     // tab.
     if (b->tab_count() == 0 && disposition == NEW_BACKGROUND_TAB)
       disposition = NEW_FOREGROUND_TAB;
 
-    b->OpenURL(url, disposition, transition);
+    b->OpenURL(url, referrer, disposition, transition);
     b->Show();
     b->MoveToFront(true);
     return;
   }
 
   if (profile_->IsOffTheRecord() && disposition == OFF_THE_RECORD)
     disposition = NEW_FOREGROUND_TAB;
 
   if (disposition == NEW_WINDOW) {
     Browser* new_browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, profile_,
                                        BrowserType::TABBED_BROWSER, L"");
-    new_contents = new_browser->AddTabWithURL(url, transition, true, instance);
+    new_contents = new_browser->AddTabWithURL(url, referrer, transition, true,
+                                              instance);
     new_browser->Show();
   } else if ((disposition == CURRENT_TAB) && current_tab) {
     if (transition == PageTransition::TYPED ||
         transition == PageTransition::AUTO_BOOKMARK ||
         transition == PageTransition::GENERATED ||
         transition == PageTransition::START_PAGE) {
       // Don't forget the openers if this tab is a New Tab page opened at the
       // end of the TabStrip (e.g. by pressing Ctrl+T). Give the user one
       // navigation of one of these transition types before resetting the
       // opener relationships (this allows for the use case of opening a new
@@ skipping 11 matching lines @@
         // If the user navigates the current tab to another page in any way
         // other than by clicking a link, we want to pro-actively forget all
         // TabStrip opener relationships since we assume they're beginning a
         // different task by reusing the current tab.
         tabstrip_model_.ForgetAllOpeners();
         // In this specific case we also want to reset the group relationship,
         // since it is now technically invalid.
         tabstrip_model_.ForgetGroup(current_tab);
       }
     }
-    current_tab->controller()->LoadURL(url, transition);
+    current_tab->controller()->LoadURL(url, referrer, transition);
     // The TabContents might have changed as part of the navigation (ex: new tab
     // page can become WebContents).
     new_contents = current_tab->controller()->active_contents();
     GetStatusBubble()->Hide();
 
     // Synchronously update the location bar. This allows us to immediately
     // have the URL bar update when the user types something, rather than
     // going through the normal system of ScheduleUIUpdate which has a delay.
     UpdateToolBar(false);
   } else if (disposition == OFF_THE_RECORD) {
     OpenURLOffTheRecord(profile_, url);
     return;
   } else if (disposition != SUPPRESS_OPEN) {
     new_contents =
-        AddTabWithURL(url, transition, disposition != NEW_BACKGROUND_TAB,
-                      instance);
+        AddTabWithURL(url, referrer, transition,
+                      disposition != NEW_BACKGROUND_TAB, instance);
   }
 
   if (disposition != NEW_BACKGROUND_TAB && source_tab_was_frontmost) {
     // Give the focus to the newly navigated tab, if the source tab was
     // front-most.
     new_contents->Focus();
   }
 }
 
 void Browser::NavigationStateChanged(const TabContents* source,
@@ skipping 556 matching lines @@
   SessionService* session_service = profile()->GetSessionService();
   if (session_service)
     session_service->WindowClosing(session_id());
 
   CloseAllTabs();
 }
 
 // Tab Creation Functions
 
 TabContents* Browser::AddTabWithURL(
-    const GURL& url, PageTransition::Type transition, bool foreground,
-    SiteInstance* instance) {
+    const GURL& url, const GURL& referrer, PageTransition::Type transition,
+    bool foreground, SiteInstance* instance) {
   if (type_ == BrowserType::APPLICATION && tabstrip_model_.count() == 1) {
     NOTREACHED() << "Cannot add a tab in a mono tab application.";
     return NULL;
   }
 
   GURL url_to_load = url;
   if (url_to_load.is_empty())
     url_to_load = GetHomePage();
   TabContents* contents =
-      CreateTabContentsForURL(url_to_load, profile_, transition, false,
-                              instance);
+      CreateTabContentsForURL(url_to_load, referrer, profile_, transition,
+                              false, instance);
   tabstrip_model_.AddTabContents(contents, -1, transition, foreground);
   // By default, content believes it is not hidden.  When adding contents
   // in the background, tell it that it's hidden.
   if (!foreground)
     contents->WasHidden();
   return contents;
 }
 
 TabContents* Browser::AddWebApplicationTab(Profile* profile,
                                            WebApp* web_app,
                                            bool lazy) {
   DCHECK(web_app);
 
   // TODO(acw): Do we need an "application launched" transition type?
   // TODO(creis): Should we reuse the current instance (ie. process) here?
   TabContents* contents =
-      CreateTabContentsForURL(web_app->url(), profile, PageTransition::LINK,
-                              lazy, NULL);
+      CreateTabContentsForURL(web_app->url(), GURL(), profile,
+                              PageTransition::LINK, lazy, NULL);
   if (contents->AsWebContents())
     contents->AsWebContents()->SetWebApp(web_app);
 
   if (lazy) {
     contents->controller()->LoadURLLazily(
-        web_app->url(), PageTransition::LINK, web_app->name(), NULL);
+        web_app->url(), GURL(), PageTransition::LINK, web_app->name(), NULL);
   }
   tabstrip_model_.AddTabContents(contents, -1, PageTransition::LINK, !lazy);
   return contents;
 }
 
 TabContents* Browser::AddTabWithNavigationController(
     NavigationController* ctrl, PageTransition::Type type) {
   TabContents* tc = ctrl->active_contents();
   tabstrip_model_.AddTabContents(tc, -1, type, true);
   return tc;
@@ skipping 66 matching lines @@
   if (BrowserList::GetBrowserCountForType(profile_,
                                           BrowserType::TABBED_BROWSER) > 1 ||
       tab_count() > 1)
     result |= TAB_TEAROFF_ACTION;
   if (tab_count() > 1)
     result |= TAB_MOVE_ACTION;
   return result;
 }
 
 TabContents* Browser::CreateTabContentsForURL(
-    const GURL& url, Profile* profile, PageTransition::Type transition,
-    bool defer_load, SiteInstance* instance) const {
+    const GURL& url, const GURL& referrer, Profile* profile,
+    PageTransition::Type transition, bool defer_load,
+    SiteInstance* instance) const {
   // Create an appropriate tab contents.
   GURL real_url = url;
   TabContentsType type = TabContents::TypeForURL(&real_url);
   DCHECK(type != TAB_CONTENTS_UNKNOWN_TYPE);
 
   TabContents* contents =
     TabContents::CreateWithType(type, GetTopLevelHWND(), profile, instance);
   contents->SetupController(profile);
 
   if (!defer_load) {
     // Load the initial URL before adding the new tab contents to the tab strip
     // so that the tab contents has navigation state.
-    contents->controller()->LoadURL(url, transition);
+    contents->controller()->LoadURL(url, referrer, transition);
   }
 
   return contents;
 }
 
 void Browser::ShowApplicationMenu(const gfx::Point& p) {
   if (!window_)
     return;
 
   HWND hwnd = reinterpret_cast<HWND>(window_->GetPlatformID());
@@ skipping 247 matching lines @@
   TabContents* tc;
   for (i = 0, c = tabstrip_model_.count(); i < c; ++i) {
     tc = tabstrip_model_.GetTabContentsAt(i);
     if (tc->type() == TAB_CONTENTS_NATIVE_UI &&
         tc->GetURL() == url) {
       tabstrip_model_.SelectTabContentsAt(i, false);
       return;
     }
   }
 
-  TabContents* contents = CreateTabContentsForURL(url, profile_,
+  TabContents* contents = CreateTabContentsForURL(url, GURL(), profile_,
                                                   PageTransition::LINK, false,
                                                   NULL);
   AddNewContents(NULL, contents, NEW_FOREGROUND_TAB, gfx::Rect(), true);
 }
 
 NavigationController* Browser::BuildRestoredNavigationController(
       const std::vector<TabNavigation>& navigations,
       int selected_navigation) {
   if (!navigations.empty()) {
     DCHECK(selected_navigation >= 0 &&
            selected_navigation < static_cast<int>(navigations.size()));
     // We should have a valid URL, if we don't fall back to the default.
     GURL url = navigations[selected_navigation].url;
     if (url.is_empty())
       url = GetHomePage();
 
     // Create a NavigationController. This constructor creates the appropriate
     // set of TabContents.
     return new NavigationController(
         profile_, navigations, selected_navigation, GetTopLevelHWND());
   } else {
     // No navigations. Create a tab with about:blank.
     TabContents* contents =
-        CreateTabContentsForURL(GURL("about:blank"), profile_,
+        CreateTabContentsForURL(GURL("about:blank"), GURL(), profile_,
                                 PageTransition::START_PAGE, false, NULL);
     return new NavigationController(contents, profile_);
   }
 }
 
 // static
 void Browser::OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Profile* off_the_record_profile = profile->GetOffTheRecordProfile();
   Browser* browser = BrowserList::FindBrowserWithType(
       off_the_record_profile, BrowserType::TABBED_BROWSER);
   if (browser == NULL) {
     browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, off_the_record_profile,
                           BrowserType::TABBED_BROWSER, L"");
   }
-  browser->AddTabWithURL(url, PageTransition::LINK, true, NULL);
+  // TODO(eroman): should we have referrer here?
+  browser->AddTabWithURL(url, GURL(), PageTransition::LINK, true, NULL);
   browser->Show();
   browser->MoveToFront(true);
 }
 
 // static
 std::wstring Browser::ComputePopupTitle(const GURL& url,
                                         const std::wstring& title) {
   DCHECK(!g_browser_process->IsUsingNewFrames());
   std::wstring result(title);
   FormatTitleForDisplay(&result);
@@ skipping 196 matching lines @@
 void Browser::FormatTitleForDisplay(std::wstring* title) {
   size_t current_index = 0;
   size_t match_index;
   while ((match_index = title->find(L'\n', current_index)) !=
          std::wstring::npos) {
     title->replace(match_index, 1, L"");
     current_index = match_index;
   }
 }