Plumb the referrer throughout the OpenURL APIs....

chrome/browser/navigation_controller.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/navigation_controller.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 128 matching lines @@
   for (std::vector<TabNavigation>::const_iterator i =
            navigations.begin(); i != navigations.end(); ++i) {
     const TabNavigation& navigation = *i;
 
     GURL real_url = navigation.url;
     TabContentsType type = TabContents::TypeForURL(&real_url);
     DCHECK(type != TAB_CONTENTS_UNKNOWN_TYPE);
 
     NavigationEntry* entry = new NavigationEntry(
         type,
-        NULL,  // The site instance for restored tabs is sent on naviagion
+        NULL,  // The site instance for restored tabs is sent on naviagtion
                // (WebContents::GetSiteInstanceForEntry).
         static_cast<int>(i - navigations.begin()),
         real_url,
+        GURL(), // TODO(eroman): should pass actual referrer.
         navigation.title,
         // Use a transition type of reload so that we don't incorrectly
         // increase the typed count.
         PageTransition::RELOAD);
     entry->set_display_url(navigation.url);
     entry->set_content_state(navigation.state);
     entry->set_has_post_data(
         navigation.type_mask & TabNavigation::HAS_POST_DATA);
     entries->push_back(linked_ptr<NavigationEntry>(entry));
   }
@@ skipping 238 matching lines @@
 
   if (last_committed_entry_index_ == index) {
     last_committed_entry_index_--;
     // We removed the currently shown entry, so we have to load something else.
     if (last_committed_entry_index_ != -1) {
       pending_entry_index_ = last_committed_entry_index_;
       NavigateToPendingEntry(false);
     } else {
       // If there is nothing to show, show a default page.
       LoadURL(default_url.is_empty() ? GURL("about:blank") : default_url,
-              PageTransition::START_PAGE);
+              GURL(), PageTransition::START_PAGE);
     }
   } else if (last_committed_entry_index_ > index) {
     last_committed_entry_index_--;
   }
 }
 
 void NavigationController::Destroy() {
   // Close all tab contents owned by this controller.  We make a list on the
   // stack because they are removed from the map as they are Destroyed
   // (invalidating the iterators), which may or may not occur synchronously.
@@ skipping 48 matching lines @@
 
   // Make sure we cancel any collector for that TabContents.
   CancelTabContentsCollection(type);
 
   // If that was the last tab to be destroyed, delete ourselves.
   if (tab_contents_map_.empty())
     delete this;
 }
 
 NavigationEntry* NavigationController::CreateNavigationEntry(
-    const GURL& url, PageTransition::Type transition) {
+    const GURL& url, const GURL& referrer, PageTransition::Type transition) {
   GURL real_url = url;
   TabContentsType type;
 
   // If the active contents supports |url|, use it.
   // Note: in both cases, we give TabContents a chance to rewrite the URL.
   TabContents* active = active_contents();
   if (active && active->SupportsURL(&real_url))
     type = active->type();
   else
     type = TabContents::TypeForURL(&real_url);
 
   NavigationEntry* entry = new NavigationEntry(type, NULL, -1, real_url,
+                                               referrer,
                                                std::wstring(), transition);
   entry->set_display_url(url);
   entry->set_user_typed_url(url);
   if (url.SchemeIsFile()) {
     entry->set_title(file_util::GetFilenameFromPath(UTF8ToWide(url.host() +
                                                                url.path())));
   }
   return entry;
 }
 
 void NavigationController::AddTransientEntry(NavigationEntry* entry) {
   // Discard any current transient entry, we can only have one at a time.
   int index = 0;
   if (last_committed_entry_index_ != -1)
     index = last_committed_entry_index_ + 1;
   DiscardTransientEntry();
   entries_.insert(entries_.begin() + index, linked_ptr<NavigationEntry>(entry));
   transient_entry_index_  = index;
   active_contents_->NotifyNavigationStateChanged(
       TabContents::INVALIDATE_EVERYTHING);
 }
 
-void NavigationController::LoadURL(const GURL& url,
+void NavigationController::LoadURL(const GURL& url, const GURL& referrer,
                                    PageTransition::Type transition) {
   // The user initiated a load, we don't need to reload anymore.
   needs_reload_ = false;
 
-  NavigationEntry* entry = CreateNavigationEntry(url, transition);
+  NavigationEntry* entry = CreateNavigationEntry(url, referrer, transition);
 
   LoadEntry(entry);
 }
 
 void NavigationController::LoadURLLazily(const GURL& url,
+                                         const GURL& referrer,
                                          PageTransition::Type type,
                                          const std::wstring& title,
                                          SkBitmap* icon) {
-  NavigationEntry* entry = CreateNavigationEntry(url, type);
+  NavigationEntry* entry = CreateNavigationEntry(url, referrer, type);
   entry->set_title(title);
   if (icon)
     entry->favicon().set_bitmap(*icon);
 
   DiscardNonCommittedEntriesInternal();
   pending_entry_ = entry;
   load_pending_entry_when_active_ = true;
 }
 
 bool NavigationController::LoadingURLLazily() {
@@ skipping 701 matching lines @@
       return i;
   }
   return -1;
 }
 
 NavigationEntry* NavigationController::GetTransientEntry() const {
   if (transient_entry_index_ == -1)
     return NULL;
   return entries_[transient_entry_index_].get();
 }