Added prerendering to omnibox. Enable through --prerender-from-omnibox command-line-flag or through the about:flag with the same name. Only effective if prerender is enabled and instant is disabled or restricted to search.

BUG=87124
TEST=none


Review URL: http://codereview.chromium.org/7210020

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@90384 0039d316-1c4b-4281-b951-d872f2087c98

23 files changed, 336 insertions, 163 deletions

diff --git a/chrome/app/generated_resources.grd b/chrome/app/generated_resources.grd
index f79e43a0a..e0cb65b 100644
--- a/chrome/app/generated_resources.grd
+++ b/chrome/app/generated_resources.grd
@@ -4348,6 +4348,12 @@ Keep your key file in a safe place. You will need it to create new versions of y
       <message name="IDS_FLAGS_SYNC_TYPED_URLS_DESCRIPTION" desc="Description for the flag to enable syncing the TypedURL datatype">
         Enable typed URLs in the sync options. This allows syncing your typed URL history to other clients to assist in omnibox auto-completion.
       </message>
+      <message name="IDS_FLAGS_PRERENDER_FROM_OMNIBOX_NAME" desc="Title for the flag to prerender from the omnibox">
+        Prerender from omnibox.
+      </message>
+      <message name="IDS_FLAGS_PRERENDER_FROM_OMNIBOX_DESCRIPTION" desc="Description for the flag to prerender from the omnibox">
+        Prerender suggestions given in the omnibox.
+      </message>
 
       <!-- Crashes -->
       <message name="IDS_CRASHES_TITLE" desc="Title for the chrome://crashes page.">
diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc
index 75f9d66..eeeeca3 100644
--- a/chrome/browser/about_flags.cc
+++ b/chrome/browser/about_flags.cc
@@ -376,6 +376,13 @@ const Experiment kExperiments[] = {
 #endif
     SINGLE_VALUE_TYPE(switches::kEnableSmoothScrolling)
   },
+  {
+    "prerender-from-omnibox",
+    IDS_FLAGS_PRERENDER_FROM_OMNIBOX_NAME,
+    IDS_FLAGS_PRERENDER_FROM_OMNIBOX_DESCRIPTION,
+    kOsAll,
+    SINGLE_VALUE_TYPE(switches::kPrerenderFromOmnibox)
+  },
 };
 
 const Experiment* experiments = kExperiments;
diff --git a/chrome/browser/autocomplete/autocomplete_edit.cc b/chrome/browser/autocomplete/autocomplete_edit.cc
index eb6c6a7..8c6eb8f 100644
--- a/chrome/browser/autocomplete/autocomplete_edit.cc
+++ b/chrome/browser/autocomplete/autocomplete_edit.cc
@@ -23,6 +23,7 @@
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/net/predictor_api.h"
 #include "chrome/browser/net/url_fixer_upper.h"
+#include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
@@ -79,7 +80,7 @@ AutocompleteEditModel::AutocompleteEditModel(
       control_key_state_(UP),
       is_keyword_hint_(false),
       profile_(profile),
-      update_instant_(true),
+      in_revert_(false),
       allow_exact_keyword_match_(false),
       instant_complete_behavior_(INSTANT_COMPLETE_DELAYED) {
 }
@@ -213,22 +214,33 @@ void AutocompleteEditModel::OnChanged() {
   string16 suggested_text;
   TabContentsWrapper* tab = controller_->GetTabContentsWrapper();
   bool might_support_instant = false;
-  if (update_instant_ && instant && tab) {
-    if (user_input_in_progress() && popup_->IsOpen()) {
-      AutocompleteMatch current_match = CurrentMatch();
-      if (current_match.destination_url == PermanentURL()) {
-        // The destination is the same as the current url. This typically
-        // happens if the user presses the down error in the omnibox, in which
-        // case we don't want to load a preview.
-        instant->DestroyPreviewContentsAndLeaveActive();
+  if (!in_revert_ && tab) {
+    if (instant) {
+      if (user_input_in_progress() && popup_->IsOpen()) {
+        AutocompleteMatch current_match = CurrentMatch();
+        if (current_match.destination_url == PermanentURL()) {
+          // The destination is the same as the current url. This typically
+          // happens if the user presses the down error in the omnibox, in which
+          // case we don't want to load a preview.
+          instant->DestroyPreviewContentsAndLeaveActive();
+        } else {
+          instant->Update(tab, current_match, view_->GetText(),
+                          UseVerbatimInstant(), &suggested_text);
+        }
       } else {
-        instant->Update(tab, CurrentMatch(), view_->GetText(),
-                        UseVerbatimInstant(), &suggested_text);
+        instant->DestroyPreviewContents();
+      }
+      might_support_instant = instant->MightSupportInstant();
+    } else if (user_input_in_progress() && popup_->IsOpen()) {
+      // Start Prerender of this page instead.
+      CHECK(tab->tab_contents());
+      prerender::PrerenderManager* prerender_manager =
+          tab->tab_contents()->profile()->GetPrerenderManager();
+      if (prerender_manager) {
+        prerender_manager->AddPrerender(prerender::ORIGIN_OMNIBOX,
+                                        CurrentMatch().destination_url);
       }
-    } else {
-      instant->DestroyPreviewContents();
     }
-    might_support_instant = instant->MightSupportInstant();
   }
 
   if (!might_support_instant) {
@@ -399,7 +411,7 @@ void AutocompleteEditModel::StartAutocomplete(
 }
 
 void AutocompleteEditModel::StopAutocomplete() {
-  if (popup_->IsOpen() && update_instant_) {
+  if (popup_->IsOpen() && !in_revert_) {
     InstantController* instant = controller_->GetInstant();
     if (instant && !instant->commit_on_mouse_up())
       instant->DestroyPreviewContents();
@@ -534,7 +546,7 @@ void AutocompleteEditModel::OpenMatch(const AutocompleteMatch& match,
   }
 
   if (disposition != NEW_BACKGROUND_TAB) {
-    update_instant_ = false;
+    in_revert_ = true;
     view_->RevertAll();  // Revert the box to its unedited state
   }
 
@@ -548,7 +560,7 @@ void AutocompleteEditModel::OpenMatch(const AutocompleteMatch& match,
   InstantController* instant = controller_->GetInstant();
   if (instant && !popup_->IsOpen())
     instant->DestroyPreviewContents();
-  update_instant_ = true;
+  in_revert_ = false;
 }
 
 bool AutocompleteEditModel::AcceptKeyword() {
diff --git a/chrome/browser/autocomplete/autocomplete_edit.h b/chrome/browser/autocomplete/autocomplete_edit.h
index 1da8241..171a716 100644
--- a/chrome/browser/autocomplete/autocomplete_edit.h
+++ b/chrome/browser/autocomplete/autocomplete_edit.h
@@ -529,11 +529,10 @@ class AutocompleteEditModel : public AutocompleteControllerDelegate {
 
   Profile* profile_;
 
-  // Should instant be updated? This is needed as prior to accepting the current
-  // text the model is reverted, which triggers resetting instant. We don't want
-  // to update instant in this case, so we use the flag to determine if this is
-  // happening.
-  bool update_instant_;
+  // This is needed as prior to accepting the current text the model is
+  // reverted, which triggers resetting instant. We don't want to update instant
+  // in this case, so we use the flag to determine if this is happening.
+  bool in_revert_;
 
   // Indicates if the upcoming autocomplete search is allowed to be treated as
   // an exact keyword match. If it's true then keyword mode will be triggered
diff --git a/chrome/browser/instant/instant_controller.cc b/chrome/browser/instant/instant_controller.cc
index 592c0e3..7269522 100644
--- a/chrome/browser/instant/instant_controller.cc
+++ b/chrome/browser/instant/instant_controller.cc
@@ -15,6 +15,7 @@
 #include "chrome/browser/instant/promo_counter.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
@@ -167,7 +168,23 @@ void InstantController::Update(TabContentsWrapper* tab_contents,
     return;
   }
 
-  if (!ShouldShowPreviewFor(match, &template_url)) {
+  PreviewCondition preview_condition = GetPreviewConditionFor(match,
+                                                              &template_url);
+  if (preview_condition == PREVIEW_CONDITION_SUCCESS) {
+    // Do nothing if we should show it.
+  } else if (preview_condition == PREVIEW_CONDITION_INSTANT_SEARCH_ONLY) {
+    // Start Prerender of this page instead.
+    prerender::PrerenderManager* prerender_manager =
+        tab_contents_->profile()->GetPrerenderManager();
+    if (prerender_manager) {
+      prerender_manager->AddPrerender(prerender::ORIGIN_OMNIBOX,
+                                      match.destination_url);
+    }
+
+    DestroyPreviewContentsAndLeaveActive();
+    return;
+  } else {
+    // Just destroy the preview and cancel the update.
     DestroyPreviewContentsAndLeaveActive();
     return;
   }
@@ -661,8 +678,8 @@ void InstantController::UpdateLoader(const TemplateURL* template_url,
   UpdateDisplayableLoader();
 }
 
-bool InstantController::ShouldShowPreviewFor(const AutocompleteMatch& match,
-                                             const TemplateURL** template_url) {
+InstantController::PreviewCondition InstantController::GetPreviewConditionFor(
+    const AutocompleteMatch& match, const TemplateURL** template_url) {
   const TemplateURL* t_url = GetTemplateURL(match);
   if (t_url) {
     if (!t_url->id() ||
@@ -671,21 +688,21 @@ bool InstantController::ShouldShowPreviewFor(const AutocompleteMatch& match,
         !t_url->instant_url()->SupportsReplacement()) {
       // To avoid extra load on other search engines we only enable previews if
       // they support the instant API.
-      return false;
+      return PREVIEW_CONDITION_INVALID_TEMPLATE_URL;
     }
   }
   *template_url = t_url;
 
   if (match.destination_url.SchemeIs(chrome::kJavaScriptScheme))
-    return false;
+    return PREVIEW_CONDITION_JAVASCRIPT_SCHEME;
 
-  // Extension keywords don't have a real destionation URL.
+  // Extension keywords don't have a real destination URL.
   if (match.template_url && match.template_url->IsExtensionKeyword())
-    return false;
+    return PREVIEW_CONDITION_EXTENSION_KEYWORD;
 
   // Was the host blacklisted?
   if (host_blacklist_ && host_blacklist_->count(match.destination_url.host()))
-    return false;
+    return PREVIEW_CONDITION_BLACKLISTED;
 
   const CommandLine* cl = CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kRestrictInstantToSearch) &&
@@ -693,10 +710,10 @@ bool InstantController::ShouldShowPreviewFor(const AutocompleteMatch& match,
       match.type != AutocompleteMatch::SEARCH_HISTORY &&
       match.type != AutocompleteMatch::SEARCH_SUGGEST &&
       match.type != AutocompleteMatch::SEARCH_OTHER_ENGINE) {
-    return false;
+    return PREVIEW_CONDITION_INSTANT_SEARCH_ONLY;
   }
 
-  return true;
+  return PREVIEW_CONDITION_SUCCESS;
 }
 
 void InstantController::BlacklistFromInstant(TemplateURLID id) {
diff --git a/chrome/browser/instant/instant_controller.h b/chrome/browser/instant/instant_controller.h
index f8d4bd7..8556e85 100644
--- a/chrome/browser/instant/instant_controller.h
+++ b/chrome/browser/instant/instant_controller.h
@@ -193,6 +193,15 @@ class InstantController : public InstantLoaderDelegate {
  private:
   friend class InstantTest;
 
+  enum PreviewCondition {
+    PREVIEW_CONDITION_SUCCESS,
+    PREVIEW_CONDITION_INVALID_TEMPLATE_URL,
+    PREVIEW_CONDITION_JAVASCRIPT_SCHEME,
+    PREVIEW_CONDITION_EXTENSION_KEYWORD,
+    PREVIEW_CONDITION_BLACKLISTED,
+    PREVIEW_CONDITION_INSTANT_SEARCH_ONLY,
+  };
+
   typedef std::set<std::string> HostBlacklist;
 
   // Updates |displayable_loader_| and if necessary notifies the delegate.
@@ -228,10 +237,11 @@ class InstantController : public InstantLoaderDelegate {
                     bool verbatim,
                     string16* suggested_text);
 
-  // Returns true if a preview should be shown for |match|. If |match| has
-  // a TemplateURL that supports the instant API it is set in |template_url|.
-  bool ShouldShowPreviewFor(const AutocompleteMatch& match,
-                            const TemplateURL** template_url);
+  // Returns a PreviewCondition indicating why we might decide not to show a
+  // preview for |match|. If |match| has a TemplateURL that supports the instant
+  // API it is set in |template_url|.
+  PreviewCondition GetPreviewConditionFor(const AutocompleteMatch& match,
+                                          const TemplateURL** template_url);
 
   // Marks the specified search engine id as not supporting instant.
   void BlacklistFromInstant(TemplateURLID id);
diff --git a/chrome/browser/prerender/prerender_browsertest.cc b/chrome/browser/prerender/prerender_browsertest.cc
index 1b598c2..8bb5b76 100644
--- a/chrome/browser/prerender/prerender_browsertest.cc
+++ b/chrome/browser/prerender/prerender_browsertest.cc
@@ -98,7 +98,7 @@ class TestPrerenderContents : public PrerenderContents {
       int number_of_loads,
       FinalStatus expected_final_status)
       : PrerenderContents(prerender_manager, prerender_tracker, profile,
-                          url, referrer),
+                          url, referrer, ORIGIN_LINK_REL_PRERENDER),
         number_of_loads_(0),
         expected_number_of_loads_(number_of_loads),
         expected_final_status_(expected_final_status),
@@ -243,7 +243,8 @@ class WaitForLoadPrerenderContentsFactory : public PrerenderContents::Factory {
       PrerenderTracker* prerender_tracker,
       Profile* profile,
       const GURL& url,
-      const GURL& referrer) OVERRIDE {
+      const GURL& referrer,
+      Origin origin) OVERRIDE {
     CHECK(!expected_final_status_queue_.empty()) <<
           "Creating prerender contents for " << url.path() <<
           " with no expected final status";
diff --git a/chrome/browser/prerender/prerender_contents.cc b/chrome/browser/prerender/prerender_contents.cc
index ae72b91..ec5c727 100644
--- a/chrome/browser/prerender/prerender_contents.cc
+++ b/chrome/browser/prerender/prerender_contents.cc
@@ -60,9 +60,10 @@ class PrerenderContentsFactoryImpl : public PrerenderContents::Factory {
  public:
   virtual PrerenderContents* CreatePrerenderContents(
       PrerenderManager* prerender_manager, PrerenderTracker* prerender_tracker,
-      Profile* profile, const GURL& url, const GURL& referrer) OVERRIDE {
+      Profile* profile, const GURL& url, const GURL& referrer,
+      Origin origin) OVERRIDE {
     return new PrerenderContents(prerender_manager, prerender_tracker, profile,
-                                 url, referrer);
+                                 url, referrer, origin);
   }
 };
 
@@ -124,7 +125,8 @@ PrerenderContents::PrerenderContents(PrerenderManager* prerender_manager,
                                      PrerenderTracker* prerender_tracker,
                                      Profile* profile,
                                      const GURL& url,
-                                     const GURL& referrer)
+                                     const GURL& referrer,
+                                     Origin origin)
     : prerender_manager_(prerender_manager),
       prerender_tracker_(prerender_tracker),
       prerender_url_(url),
@@ -137,7 +139,8 @@ PrerenderContents::PrerenderContents(PrerenderManager* prerender_manager,
       prerendering_has_been_cancelled_(false),
       child_id_(-1),
       route_id_(-1),
-      starting_page_id_(-1) {
+      starting_page_id_(-1),
+      origin_(origin) {
   DCHECK(prerender_manager != NULL);
 }
 
@@ -155,8 +158,6 @@ void PrerenderContents::StartPrerendering(
   DCHECK(profile_ != NULL);
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
-  DCHECK(source_render_view_host != NULL);
-  DCHECK(source_render_view_host->view() != NULL);
 
   prerendering_has_started_ = true;
   TabContents* new_contents = new TabContents(profile_, NULL, MSG_ROUTING_NONE,
@@ -165,26 +166,29 @@ void PrerenderContents::StartPrerendering(
   TabContentsObserver::Observe(new_contents);
   prerender_contents_->download_tab_helper()->set_delegate(this);
 
-  TabContents* source_tc =
-      source_render_view_host->delegate()->GetAsTabContents();
-  if (source_tc) {
-    // So that history merging will work, get the max page ID
-    // of the old page, and add a safety margin of 10 to it (for things
-    // such as redirects).
-    starting_page_id_ = source_tc->GetMaxPageID();
-    if (starting_page_id_ < 0)
-      starting_page_id_ = 0;
-    starting_page_id_ += kPrerenderPageIdOffset;
-    prerender_contents_->controller().set_max_restored_page_id(
-        starting_page_id_);
-
-    tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
-    new_contents->set_delegate(tab_contents_delegate_.get());
-
-    // Set the size of the new TC to that of the old TC.
-    gfx::Rect tab_bounds;
-    source_tc->view()->GetContainerBounds(&tab_bounds);
-    prerender_contents_->view()->SizeContents(tab_bounds.size());
+  if (source_render_view_host) {
+    DCHECK(source_render_view_host->view() != NULL);
+    TabContents* source_tc =
+        source_render_view_host->delegate()->GetAsTabContents();
+    if (source_tc) {
+      // So that history merging will work, get the max page ID
+      // of the old page, and add a safety margin of 10 to it (for things
+      // such as redirects).
+      starting_page_id_ = source_tc->GetMaxPageID();
+      if (starting_page_id_ < 0)
+        starting_page_id_ = 0;
+      starting_page_id_ += kPrerenderPageIdOffset;
+      prerender_contents_->controller().set_max_restored_page_id(
+          starting_page_id_);
+
+      tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
+      new_contents->set_delegate(tab_contents_delegate_.get());
+
+      // Set the size of the new TC to that of the old TC.
+      gfx::Rect tab_bounds;
+      source_tc->view()->GetContainerBounds(&tab_bounds);
+      prerender_contents_->view()->SizeContents(tab_bounds.size());
+    }
   }
 
   // Register as an observer of the RenderViewHost so we get messages.
@@ -272,11 +276,12 @@ PrerenderContents::~PrerenderContents() {
   DCHECK(prerendering_has_been_cancelled_ ||
          final_status_ == FINAL_STATUS_USED ||
          final_status_ == FINAL_STATUS_CONTROL_GROUP);
+  DCHECK(origin_ != ORIGIN_MAX);
 
   // If we haven't even started prerendering, we were just in the control
   // group, which means we do not want to record the status.
   if (prerendering_has_started())
-    RecordFinalStatus(final_status_);
+    RecordFinalStatus(origin_, final_status_);
 
   if (child_id_ != -1 && route_id_ != -1)
     prerender_tracker_->OnPrerenderingFinished(child_id_, route_id_);
diff --git a/chrome/browser/prerender/prerender_contents.h b/chrome/browser/prerender/prerender_contents.h
index 8a8de52..47cba32 100644
--- a/chrome/browser/prerender/prerender_contents.h
+++ b/chrome/browser/prerender/prerender_contents.h
@@ -60,7 +60,8 @@ class PrerenderContents : public NotificationObserver,
         PrerenderTracker* prerender_tracker,
         Profile* profile,
         const GURL& url,
-        const GURL& referrer) = 0;
+        const GURL& referrer,
+        Origin origin) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Factory);
@@ -167,7 +168,8 @@ class PrerenderContents : public NotificationObserver,
                     PrerenderTracker* prerender_tracker,
                     Profile* profile,
                     const GURL& url,
-                    const GURL& referrer);
+                    const GURL& referrer,
+                    Origin origin);
 
   NotificationRegistrar& notification_registrar() {
     return notification_registrar_;
@@ -270,6 +272,9 @@ class PrerenderContents : public NotificationObserver,
   // Page ID at which prerendering started.
   int32 starting_page_id_;
 
+  // Origin for this prerender.
+  Origin origin_;
+
   // Offset by which to offset prerendered pages
   static const int32 kPrerenderPageIdOffset = 10;
 
diff --git a/chrome/browser/prerender/prerender_final_status.cc b/chrome/browser/prerender/prerender_final_status.cc
index 8d71e41..c598106 100644
--- a/chrome/browser/prerender/prerender_final_status.cc
+++ b/chrome/browser/prerender/prerender_final_status.cc
@@ -51,7 +51,7 @@ COMPILE_ASSERT(arraysize(kFinalStatusNames) == FINAL_STATUS_MAX + 1,
 
 }
 
-void RecordFinalStatus(FinalStatus final_status) {
+void RecordFinalStatus(Origin origin, FinalStatus final_status) {
   DCHECK(final_status != FINAL_STATUS_MAX);
   // FINAL_STATUS_CONTROL_GROUP indicates that the PrerenderContents
   // was created only to measure "would-have-been-prerendered" for
@@ -62,6 +62,21 @@ void RecordFinalStatus(FinalStatus final_status) {
   UMA_HISTOGRAM_ENUMERATION("Prerender.FinalStatus",
                             final_status,
                             FINAL_STATUS_MAX);
+  switch (origin) {
+    case ORIGIN_LINK_REL_PRERENDER:
+      UMA_HISTOGRAM_ENUMERATION("Prerender.FinalStatus_LinkRelPrerender",
+                                final_status,
+                                FINAL_STATUS_MAX);
+      break;
+    case ORIGIN_OMNIBOX:
+      UMA_HISTOGRAM_ENUMERATION("Prerender.FinalStatus_Omnibox",
+                                final_status,
+                                FINAL_STATUS_MAX);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  };
 }
 
 const char* NameFromFinalStatus(FinalStatus final_status) {
diff --git a/chrome/browser/prerender/prerender_final_status.h b/chrome/browser/prerender/prerender_final_status.h
index da9fec8..2713444 100644
--- a/chrome/browser/prerender/prerender_final_status.h
+++ b/chrome/browser/prerender/prerender_final_status.h
@@ -5,6 +5,8 @@
 #ifndef CHROME_BROWSER_PRERENDER_PRERENDER_FINAL_STATUS_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_FINAL_STATUS_H_
 
+#include "chrome/browser/prerender/prerender_origin.h"
+
 namespace prerender {
 
 // FinalStatus indicates whether |this| was used, or why it was cancelled.
@@ -45,7 +47,7 @@ enum FinalStatus {
   FINAL_STATUS_MAX,
 };
 
-void RecordFinalStatus(FinalStatus final_status);
+void RecordFinalStatus(Origin origin, FinalStatus final_status);
 
 // Return a human-readable name for |final_status|. |final_status|
 // is expected to be a valid value.
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index c2f0e00..50a2bd1 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -6,6 +6,7 @@
 
 #include <string>
 
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ -22,6 +23,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper_delegate.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_process_host.h"
@@ -205,11 +207,13 @@ struct PrerenderManager::NavigationRecord {
 
 struct PrerenderManager::PendingContentsData {
   PendingContentsData(const GURL& url,
-                      const GURL& referrer)
-      : url_(url), referrer_(referrer) { }
+                      const GURL& referrer,
+                      Origin origin)
+      : url_(url), referrer_(referrer), origin_(origin) { }
   ~PendingContentsData() {}
   GURL url_;
   GURL referrer_;
+  Origin origin_;
 };
 
 void HandleTag(
@@ -227,10 +231,11 @@ void HandleTag(
   std::pair<int, int> child_route_id_pair = std::make_pair(render_process_id,
                                                            render_view_id);
 
-  prerender_manager->AddPreload(child_route_id_pair, url, referrer);
+  prerender_manager->AddPrerenderFromPage(ORIGIN_LINK_REL_PRERENDER,
+                                          child_route_id_pair, url, referrer);
 }
 
-void DestroyPreloadForRenderView(
+void DestroyPrerenderForRenderView(
     const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
     int render_process_id,
     int render_view_id,
@@ -240,7 +245,7 @@ void DestroyPreloadForRenderView(
   if (!prerender_manager)
     return;
 
-  prerender_manager->DestroyPreloadForChildRouteIdPair(
+  prerender_manager->DestroyPrerenderForChildRouteIdPair(
       std::make_pair(render_process_id, render_view_id),
       final_status);
 }
@@ -276,7 +281,8 @@ void PrerenderManager::SetPrerenderContentsFactory(
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
-bool PrerenderManager::AddPreload(
+bool PrerenderManager::AddPrerenderFromPage(
+    Origin origin,
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url_arg,
     const GURL& referrer) {
@@ -285,7 +291,7 @@ bool PrerenderManager::AddPreload(
   // If the referring page is prerendering, defer the prerender.
   if (FindPrerenderContentsForChildRouteIdPair(child_route_id_pair) !=
           prerender_list_.end()) {
-    AddPendingPreload(child_route_id_pair, url_arg, referrer);
+    AddPendingPrerender(origin, child_route_id_pair, url_arg, referrer);
     return true;
   }
 
@@ -313,7 +319,7 @@ bool PrerenderManager::AddPreload(
   // case, when a new tab is added to a process used for prerendering.
   if (RenderProcessHost::ShouldTryToUseExistingProcessHost() &&
       !RenderProcessHost::run_renderer_in_process()) {
-    RecordFinalStatus(FINAL_STATUS_TOO_MANY_PROCESSES);
+    RecordFinalStatus(origin, FINAL_STATUS_TOO_MANY_PROCESSES);
     return false;
   }
 
@@ -322,7 +328,7 @@ bool PrerenderManager::AddPreload(
     // Cancel the prerender. We could add it to the pending prerender list but
     // this doesn't make sense as the next prerender request will be triggered
     // by a navigation and is unlikely to be the same site.
-    RecordFinalStatus(FINAL_STATUS_RATE_LIMIT_EXCEEDED);
+    RecordFinalStatus(origin, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return false;
   }
 
@@ -335,13 +341,13 @@ bool PrerenderManager::AddPreload(
     // Don't prerender page if parent RenderViewHost no longer exists, or it has
     // no view.  The latter should only happen when the RenderView has closed.
     if (!source_render_view_host || !source_render_view_host->view()) {
-      RecordFinalStatus(FINAL_STATUS_SOURCE_RENDER_VIEW_CLOSED);
+      RecordFinalStatus(origin, FINAL_STATUS_SOURCE_RENDER_VIEW_CLOSED);
       return false;
     }
   }
 
   PrerenderContents* prerender_contents =
-      CreatePrerenderContents(url, referrer);
+      CreatePrerenderContents(url, referrer, origin);
   if (!prerender_contents || !prerender_contents->Init())
     return false;
 
@@ -349,6 +355,7 @@ bool PrerenderManager::AddPreload(
   PrerenderContentsData data(prerender_contents, GetCurrentTime());
 
   prerender_list_.push_back(data);
+
   if (IsControlGroup()) {
     data.contents_->set_final_status(FINAL_STATUS_CONTROL_GROUP);
   } else {
@@ -364,7 +371,21 @@ bool PrerenderManager::AddPreload(
   return true;
 }
 
-void PrerenderManager::AddPendingPreload(
+bool PrerenderManager::AddPrerender(Origin origin, const GURL& url) {
+  bool should_prerender = true;
+  if (origin == ORIGIN_OMNIBOX) {
+    CommandLine* cl = CommandLine::ForCurrentProcess();
+    should_prerender = cl->HasSwitch(switches::kPrerenderFromOmnibox);
+  }
+
+  if (!should_prerender)
+    return false;
+
+  return AddPrerenderFromPage(origin, std::make_pair(-1, -1), url, GURL());
+}
+
+void PrerenderManager::AddPendingPrerender(
+    Origin origin,
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url,
     const GURL& referrer) {
@@ -378,7 +399,7 @@ void PrerenderManager::AddPendingPreload(
     it = pending_prerender_list_.insert(el).first;
   }
 
-  it->second.push_back(PendingContentsData(url, referrer));
+  it->second.push_back(PendingContentsData(url, referrer, origin));
 }
 
 std::list<PrerenderManager::PrerenderContentsData>::iterator
@@ -403,7 +424,7 @@ std::list<PrerenderManager::PrerenderContentsData>::iterator
   return it;
 }
 
-void PrerenderManager::DestroyPreloadForChildRouteIdPair(
+void PrerenderManager::DestroyPrerenderForChildRouteIdPair(
     const std::pair<int, int>& child_route_id_pair,
     FinalStatus final_status) {
   DCHECK(CalledOnValidThread());
@@ -453,9 +474,9 @@ PrerenderContents* PrerenderManager::GetEntry(const GURL& url) {
   return GetEntryButNotSpecifiedTC(url, NULL);
 }
 
-bool PrerenderManager::MaybeUsePreloadedPage(TabContents* tab_contents,
-                                             const GURL& url,
-                                             bool has_opener_set) {
+bool PrerenderManager::MaybeUsePrerenderedPage(TabContents* tab_contents,
+                                               const GURL& url,
+                                               bool has_opener_set) {
   DCHECK(CalledOnValidThread());
   scoped_ptr<PrerenderContents> prerender_contents(
       GetEntryButNotSpecifiedTC(url, tab_contents));
@@ -560,7 +581,8 @@ bool PrerenderManager::MaybeUsePreloadedPage(TabContents* tab_contents,
     for (std::vector<PendingContentsData>::iterator content_it =
             pending_it->second.begin();
          content_it != pending_it->second.end(); ++content_it) {
-      AddPreload(pending_it->first, content_it->url_, content_it->referrer_);
+      AddPrerenderFromPage(content_it->origin_, pending_it->first,
+                           content_it->url_, content_it->referrer_);
     }
     pending_prerender_list_.erase(pending_it);
   }
@@ -588,7 +610,7 @@ void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry) {
        it != prerender_list_.end();
        ++it) {
     if (it->contents_ == entry) {
-      RemovePendingPreload(entry);
+      RemovePendingPrerender(entry);
       prerender_list_.erase(it);
       break;
     }
@@ -629,10 +651,11 @@ bool PrerenderManager::IsPrerenderElementFresh(const base::Time start) const {
 
 PrerenderContents* PrerenderManager::CreatePrerenderContents(
     const GURL& url,
-    const GURL& referrer) {
+    const GURL& referrer,
+    Origin origin) {
   DCHECK(CalledOnValidThread());
   return prerender_contents_factory_->CreatePrerenderContents(
-      this, prerender_tracker_, profile_, url, referrer);
+      this, prerender_tracker_, profile_, url, referrer, origin);
 }
 
 void PrerenderManager::DeletePendingDeleteEntries() {
@@ -772,7 +795,7 @@ void PrerenderManager::RecordTagObserved() {
   last_prerender_seen_time_ = base::TimeTicks::Now();
 }
 
-void PrerenderManager::RemovePendingPreload(PrerenderContents* entry) {
+void PrerenderManager::RemovePendingPrerender(PrerenderContents* entry) {
   DCHECK(CalledOnValidThread());
   int child_id;
   int route_id;
diff --git a/chrome/browser/prerender/prerender_manager.h b/chrome/browser/prerender/prerender_manager.h
index 96e3090..a5cf15c 100644
--- a/chrome/browser/prerender/prerender_manager.h
+++ b/chrome/browser/prerender/prerender_manager.h
@@ -19,6 +19,7 @@
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/prerender/prerender_contents.h"
+#include "chrome/browser/prerender/prerender_origin.h"
 #include "googleurl/src/gurl.h"
 
 class Profile;
@@ -51,7 +52,7 @@ void HandleTag(
     const GURL& url,
     const GURL& referrer);
 
-void DestroyPreloadForRenderView(
+void DestroyPrerenderForRenderView(
     const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
     int child_id,
     int route_id,
@@ -86,30 +87,38 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
 
   virtual ~PrerenderManager();
 
-  // Preloads |url| if valid.  |child_route_id_pair| identifies the
+  // Starts a prerender for |url| if valid. |child_route_id_pair| identifies the
   // RenderViewHost that the prerender request came from and is used to
   // set the initial window size of the RenderViewHost used for prerendering.
   // Returns true if the URL was added, false if it was not.
   // If |child_route_id_pair| itself is prerendering, adds the preloads as
-  // a pending preload.
-  bool AddPreload(
+  // a pending preload. |origin| enumerates the source of the prerender for
+  // data-tracking purposes.
+  bool AddPrerenderFromPage(
+      Origin origin,
       const std::pair<int, int>& child_route_id_pair,
       const GURL& url,
       const GURL& referrer);
 
-  // Destroy all preloads for the given child route id pair and assign a final
+  // Starts a prerender for |url| if valid. As the prerender request is coming
+  // from a source without a RenderViewHost (ie, the omnibox) we don't have a
+  // child or route id, or a referrer. This method uses sensible values for
+  // those.
+  bool AddPrerender(Origin origin, const GURL& url);
+
+  // Destroy all prerenders for the given child route id pair and assign a final
   // status to them.
-  virtual void DestroyPreloadForChildRouteIdPair(
+  virtual void DestroyPrerenderForChildRouteIdPair(
       const std::pair<int, int>& child_route_id_pair,
       FinalStatus final_status);
 
   // For a given TabContents that wants to navigate to the URL supplied,
-  // determines whether a preloaded version of the URL can be used,
+  // determines whether a prerendered version of the URL can be used,
   // and substitutes the prerendered RVH into the TabContents.  Returns
   // whether or not a prerendered RVH could be used or not.
-  bool MaybeUsePreloadedPage(TabContents* tab_contents,
-                             const GURL& url,
-                             bool has_opener_set);
+  bool MaybeUsePrerenderedPage(TabContents* tab_contents,
+                               const GURL& url,
+                               bool has_opener_set);
 
   // Moves a PrerenderContents to the pending delete list from the list of
   // active prerenders when prerendering should be cancelled.
@@ -240,9 +249,10 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   // Adds a pending preload issued by the prerendering RenderView identified by
   // |child_route_id_pair|.  If and when that prerendering RenderView is used,
   // the specified prerender will start.
-  void AddPendingPreload(const std::pair<int, int>& child_route_id_pair,
-                         const GURL& url,
-                         const GURL& referrer);
+  void AddPendingPrerender(Origin origin,
+                           const std::pair<int, int>& child_route_id_pair,
+                           const GURL& url,
+                           const GURL& referrer);
 
   // Starts scheduling periodic cleanups.
   void StartSchedulingPeriodicCleanups();
@@ -264,9 +274,9 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   void DeleteOldEntries();
   virtual base::Time GetCurrentTime() const;
   virtual base::TimeTicks GetCurrentTimeTicks() const;
-  virtual PrerenderContents* CreatePrerenderContents(
-      const GURL& url,
-      const GURL& referrer);
+  virtual PrerenderContents* CreatePrerenderContents(const GURL& url,
+                                                     const GURL& referrer,
+                                                     Origin origin);
 
   // Deletes any PrerenderContents that have been added to the pending delete
   // list.
@@ -290,7 +300,7 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
 
   // Called when removing a preload to ensure we clean up any pending preloads
   // that might remain in the map.
-  void RemovePendingPreload(PrerenderContents* entry);
+  void RemovePendingPrerender(PrerenderContents* entry);
 
   bool DoesRateLimitAllowPrerender() const;
 
diff --git a/chrome/browser/prerender/prerender_manager_unittest.cc b/chrome/browser/prerender/prerender_manager_unittest.cc
index 63b2a63..dd96725 100644
--- a/chrome/browser/prerender/prerender_manager_unittest.cc
+++ b/chrome/browser/prerender/prerender_manager_unittest.cc
@@ -6,6 +6,7 @@
 #include "base/time.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_manager.h"
+#include "chrome/browser/prerender/prerender_origin.h"
 #include "chrome/test/testing_browser_process.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_view_host.h"
@@ -24,7 +25,7 @@ class DummyPrerenderContents : public PrerenderContents {
                          const GURL& url,
                          FinalStatus expected_final_status)
       : PrerenderContents(prerender_manager, prerender_tracker, NULL, url,
-                          GURL()),
+                          GURL(), ORIGIN_LINK_REL_PRERENDER),
         has_started_(false),
         expected_final_status_(expected_final_status) {
   }
@@ -118,9 +119,9 @@ class TestPrerenderManager : public PrerenderManager {
     return prerender_contents;
   }
 
-  // Shorthand to add a simple preload with no aliases.
-  bool AddSimplePreload(const GURL& url) {
-    return AddPreload(std::pair<int, int>(-1, -1), url, GURL());
+  // Shorthand to add a simple preload with a reasonable source.
+  bool AddSimplePrerender(const GURL& url) {
+    return AddPrerender(ORIGIN_LINK_REL_PRERENDER, url);
   }
 
   bool IsPendingEntry(const GURL& url) {
@@ -151,7 +152,8 @@ class TestPrerenderManager : public PrerenderManager {
 
   virtual PrerenderContents* CreatePrerenderContents(
       const GURL& url,
-      const GURL& referrer) OVERRIDE {
+      const GURL& referrer,
+      Origin origin) OVERRIDE {
     DCHECK(next_prerender_contents_.get());
     return next_prerender_contents_.release();
   }
@@ -203,7 +205,7 @@ class PrerenderManagerTest : public testing::Test {
 
 TEST_F(PrerenderManagerTest, EmptyTest) {
   GURL url("http://www.google.com/");
-  EXPECT_FALSE(prerender_manager()->MaybeUsePreloadedPage(NULL, url, false));
+  EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage(NULL, url, false));
 }
 
 TEST_F(PrerenderManagerTest, FoundTest) {
@@ -212,7 +214,7 @@ TEST_F(PrerenderManagerTest, FoundTest) {
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->has_started());
   ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url));
 }
@@ -226,7 +228,7 @@ TEST_F(PrerenderManagerTest, DropSecondRequestTest) {
           url,
           FINAL_STATUS_USED);
   DummyPrerenderContents* null = NULL;
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->has_started());
 
@@ -234,7 +236,7 @@ TEST_F(PrerenderManagerTest, DropSecondRequestTest) {
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_MANAGER_SHUTDOWN);
-  EXPECT_FALSE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_EQ(prerender_contents1,
             prerender_manager()->next_prerender_contents());
   EXPECT_FALSE(prerender_contents1->has_started());
@@ -250,7 +252,7 @@ TEST_F(PrerenderManagerTest, ExpireTest) {
           url,
           FINAL_STATUS_TIMED_OUT);
   DummyPrerenderContents* null = NULL;
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->has_started());
   prerender_manager()->AdvanceTime(prerender_manager()->max_prerender_age()
@@ -267,7 +269,7 @@ TEST_F(PrerenderManagerTest, DropOldestRequestTest) {
           url,
           FINAL_STATUS_EVICTED);
   DummyPrerenderContents* null = NULL;
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->has_started());
 
@@ -276,7 +278,7 @@ TEST_F(PrerenderManagerTest, DropOldestRequestTest) {
       prerender_manager()->CreateNextPrerenderContents(
           url1,
           FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url1));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents1->has_started());
 
@@ -294,7 +296,7 @@ TEST_F(PrerenderManagerTest, TwoElementPrerenderTest) {
           url,
           FINAL_STATUS_EVICTED);
   DummyPrerenderContents* null = NULL;
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->has_started());
 
@@ -303,7 +305,7 @@ TEST_F(PrerenderManagerTest, TwoElementPrerenderTest) {
       prerender_manager()->CreateNextPrerenderContents(
           url1,
           FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url1));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents1->has_started());
 
@@ -312,7 +314,7 @@ TEST_F(PrerenderManagerTest, TwoElementPrerenderTest) {
       prerender_manager()->CreateNextPrerenderContents(
           url2,
           FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url2));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url2));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents2->has_started());
 
@@ -334,25 +336,25 @@ TEST_F(PrerenderManagerTest, AliasURLTest) {
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, alias_urls, FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url));
   ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1));
   prerender_contents = prerender_manager()->CreateNextPrerenderContents(
           url, alias_urls, FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2));
   prerender_contents = prerender_manager()->CreateNextPrerenderContents(
           url, alias_urls, FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url));
 
   // Test that alias URLs can not be added.
   prerender_contents = prerender_manager()->CreateNextPrerenderContents(
           url, alias_urls, FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
-  EXPECT_FALSE(prerender_manager()->AddSimplePreload(url));
-  EXPECT_FALSE(prerender_manager()->AddSimplePreload(alias_url1));
-  EXPECT_FALSE(prerender_manager()->AddSimplePreload(alias_url2));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
+  EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url));
+  EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url1));
+  EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url2));
   ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url));
 }
 
@@ -364,7 +366,7 @@ TEST_F(PrerenderManagerTest, RateLimitInWindowTest) {
           url,
           FINAL_STATUS_MANAGER_SHUTDOWN);
   DummyPrerenderContents* null = NULL;
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->has_started());
 
@@ -375,7 +377,7 @@ TEST_F(PrerenderManagerTest, RateLimitInWindowTest) {
   prerender_manager()->CreateNextPrerenderContents(
       url,
       FINAL_STATUS_MANAGER_SHUTDOWN);
-  EXPECT_FALSE(prerender_manager()->AddSimplePreload(url1));
+  EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url1));
   prerender_manager()->set_rate_limit_enabled(false);
 }
 
@@ -387,7 +389,7 @@ TEST_F(PrerenderManagerTest, RateLimitOutsideWindowTest) {
           url,
           FINAL_STATUS_EVICTED);
   DummyPrerenderContents* null = NULL;
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->has_started());
 
@@ -400,19 +402,19 @@ TEST_F(PrerenderManagerTest, RateLimitOutsideWindowTest) {
       prerender_manager()->CreateNextPrerenderContents(
           url1,
           FINAL_STATUS_MANAGER_SHUTDOWN);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url1));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(rate_limit_prerender_contents->has_started());
   prerender_manager()->set_rate_limit_enabled(false);
 }
 
-TEST_F(PrerenderManagerTest, PendingPreloadTest) {
+TEST_F(PrerenderManagerTest, PendingPrerenderTest) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
 
   int child_id;
   int route_id;
@@ -421,10 +423,9 @@ TEST_F(PrerenderManagerTest, PendingPreloadTest) {
 
   GURL pending_url("http://news.google.com/");
 
-  EXPECT_TRUE(
-      prerender_manager()->AddPreload(std::make_pair(child_id, route_id),
-                                      pending_url,
-                                      url));
+  EXPECT_TRUE(prerender_manager()->AddPrerenderFromPage(
+      ORIGIN_LINK_REL_PRERENDER, std::make_pair(child_id, route_id),
+      pending_url, url));
 
   EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url));
   EXPECT_TRUE(prerender_contents->has_started());
@@ -460,7 +461,7 @@ TEST_F(PrerenderManagerTest, ControlGroup) {
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_CONTROL_GROUP);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_FALSE(prerender_contents->has_started());
 }
 
@@ -472,8 +473,8 @@ TEST_F(PrerenderManagerTest, SourceRenderViewClosed) {
   prerender_manager()->CreateNextPrerenderContents(
       url,
       FINAL_STATUS_MANAGER_SHUTDOWN);
-  EXPECT_FALSE(prerender_manager()->AddPreload(
-      std::pair<int, int>(100, 100), url, GURL()));
+  EXPECT_FALSE(prerender_manager()->AddPrerenderFromPage(
+      ORIGIN_LINK_REL_PRERENDER, std::pair<int, int>(100, 100), url, GURL()));
 }
 
 // Tests that the prerender manager ignores fragment references when matching
@@ -485,7 +486,7 @@ TEST_F(PrerenderManagerTest, PageMatchesFragmentTest) {
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(url,
                                                        FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->has_started());
   ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url));
 }
@@ -499,7 +500,7 @@ TEST_F(PrerenderManagerTest, FragmentMatchesPageTest) {
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(fragment_url,
                                                        FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(fragment_url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url));
   EXPECT_TRUE(prerender_contents->has_started());
   ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url));
 }
@@ -513,7 +514,7 @@ TEST_F(PrerenderManagerTest, FragmentMatchesFragmentTest) {
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(fragment_url,
                                                        FINAL_STATUS_USED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(fragment_url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url));
   EXPECT_TRUE(prerender_contents->has_started());
   ASSERT_EQ(prerender_contents,
             prerender_manager()->GetEntry(other_fragment_url));
@@ -526,7 +527,7 @@ TEST_F(PrerenderManagerTest, ClearTest) {
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_CACHE_OR_HISTORY_CLEARED);
-  EXPECT_TRUE(prerender_manager()->AddSimplePreload(url));
+  EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->has_started());
   prerender_manager()->ClearData(PrerenderManager::CLEAR_PRERENDER_CONTENTS);
   DummyPrerenderContents* null = NULL;
diff --git a/chrome/browser/prerender/prerender_observer.cc b/chrome/browser/prerender/prerender_observer.cc
index eb5e257..b75d945 100644
--- a/chrome/browser/prerender/prerender_observer.cc
+++ b/chrome/browser/prerender/prerender_observer.cc
@@ -32,7 +32,7 @@ void PrerenderObserver::ProvisionalChangeToMainFrameUrl(const GURL& url,
   if (prerender_manager->IsTabContentsPrerendering(tab_contents()))
     return;
   prerender_manager->MarkTabContentsAsNotPrerendered(tab_contents());
-  MaybeUsePreloadedPage(url, has_opener_set);
+  MaybeUsePrerenderedPage(url, has_opener_set);
   prerender_manager->RecordNavigation(url);
 }
 
@@ -72,15 +72,15 @@ PrerenderManager* PrerenderObserver::MaybeGetPrerenderManager() {
   return tab_contents()->profile()->GetPrerenderManager();
 }
 
-bool PrerenderObserver::MaybeUsePreloadedPage(const GURL& url,
-                                              bool has_opener_set) {
+bool PrerenderObserver::MaybeUsePrerenderedPage(const GURL& url,
+                                                bool has_opener_set) {
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return false;
   DCHECK(!prerender_manager->IsTabContentsPrerendering(tab_contents()));
-  return prerender_manager->MaybeUsePreloadedPage(tab_contents(),
-                                                  url,
-                                                  has_opener_set);
+  return prerender_manager->MaybeUsePrerenderedPage(tab_contents(),
+                                                    url,
+                                                    has_opener_set);
 }
 
 bool PrerenderObserver::IsPrerendering() {
diff --git a/chrome/browser/prerender/prerender_observer.h b/chrome/browser/prerender/prerender_observer.h
index 9f8526a..d851191 100644
--- a/chrome/browser/prerender/prerender_observer.h
+++ b/chrome/browser/prerender/prerender_observer.h
@@ -46,7 +46,7 @@ class PrerenderObserver : public TabContentsObserver {
   // Checks with the PrerenderManager if the specified URL has been preloaded,
   // and if so, swap the RenderViewHost with the preload into this TabContents
   // object.
-  bool MaybeUsePreloadedPage(const GURL& url, bool has_opener_set);
+  bool MaybeUsePrerenderedPage(const GURL& url, bool has_opener_set);
 
   // Returns whether the TabContents being observed is currently prerendering.
   bool IsPrerendering();
diff --git a/chrome/browser/prerender/prerender_origin.cc b/chrome/browser/prerender/prerender_origin.cc
new file mode 100644
index 0000000..5aab26c
--- /dev/null
+++ b/chrome/browser/prerender/prerender_origin.cc
@@ -0,0 +1,30 @@
+// 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/prerender/prerender_origin.h"
+
+#include "base/metrics/histogram.h"
+#include "chrome/browser/prerender/prerender_manager.h"
+
+namespace prerender {
+
+namespace {
+
+const char* kOriginNames[] = {
+  "Link Rel Prerender",
+  "Omnibox",
+  "Max"
+};
+COMPILE_ASSERT(arraysize(kOriginNames) == ORIGIN_MAX + 1,
+               PrerenderOrigin_name_count_mismatch);
+
+}
+
+const char* NameFromOrigin(Origin origin) {
+  DCHECK(static_cast<int>(origin) >= 0 &&
+         origin <= ORIGIN_MAX);
+  return kOriginNames[origin];
+}
+
+}  // namespace prerender
diff --git a/chrome/browser/prerender/prerender_origin.h b/chrome/browser/prerender/prerender_origin.h
new file mode 100644
index 0000000..6b7fe0aa
--- /dev/null
+++ b/chrome/browser/prerender/prerender_origin.h
@@ -0,0 +1,23 @@
+// 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.
+
+#ifndef CHROME_BROWSER_PRERENDER_PRERENDER_ORIGIN_H_
+#define CHROME_BROWSER_PRERENDER_PRERENDER_ORIGIN_H_
+
+namespace prerender {
+
+// Origin indicates what caused the prerender.
+// NOTE: New values need to be appended, since they are used in histograms.
+enum Origin {
+  ORIGIN_LINK_REL_PRERENDER = 0,
+  ORIGIN_OMNIBOX = 1,
+  ORIGIN_MAX
+};
+
+// Return a human-readable name for |origin|.
+const char* NameFromOrigin(Origin origin);
+
+}  // namespace prerender
+
+#endif  // CHROME_BROWSER_PRERENDER_PRERENDER_ORIGIN_H_
diff --git a/chrome/browser/prerender/prerender_tracker.cc b/chrome/browser/prerender/prerender_tracker.cc
index b209ae9..719dae4 100644
--- a/chrome/browser/prerender/prerender_tracker.cc
+++ b/chrome/browser/prerender/prerender_tracker.cc
@@ -287,7 +287,7 @@ bool PrerenderTracker::SetFinalStatus(int child_id, int route_id,
     if (desired_final_status != FINAL_STATUS_USED) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
-          NewRunnableFunction(&DestroyPreloadForRenderView,
+          NewRunnableFunction(&DestroyPrerenderForRenderView,
                               final_status_it->second.prerender_manager,
                               child_id,
                               route_id,
diff --git a/chrome/browser/prerender/prerender_tracker_unittest.cc b/chrome/browser/prerender/prerender_tracker_unittest.cc
index 2518b691..c1cd80b 100644
--- a/chrome/browser/prerender/prerender_tracker_unittest.cc
+++ b/chrome/browser/prerender/prerender_tracker_unittest.cc
@@ -22,7 +22,7 @@ class TestPrerenderManager : public PrerenderManager {
     rate_limit_enabled_ = false;
   }
 
-  virtual void DestroyPreloadForChildRouteIdPair(
+  virtual void DestroyPrerenderForChildRouteIdPair(
       const std::pair<int, int>& child_route_id_pair,
       FinalStatus final_status) OVERRIDE {
     cancelled_id_pairs_.insert(child_route_id_pair);
@@ -111,8 +111,8 @@ TEST_F(PrerenderTrackerTest, PrerenderTrackerUsed) {
       0, 0, FINAL_STATUS_TIMED_OUT));
   EXPECT_EQ(FINAL_STATUS_USED, GetCurrentStatus(0, 0));
 
-  // This would call DestroyPreloadForChildRouteIdPair(), if the prerender were
-  // cancelled.
+  // This would call DestroyPrerenderForChildRouteIdPair(), if the prerender
+  // were cancelled.
   RunEvents();
 
   // These functions should all behave as before.
@@ -121,7 +121,7 @@ TEST_F(PrerenderTrackerTest, PrerenderTrackerUsed) {
       0, 0, FINAL_STATUS_TIMED_OUT));
   EXPECT_EQ(FINAL_STATUS_USED, GetCurrentStatus(0, 0));
 
-  // This calls DestroyPreloadForChildRouteIdPair().
+  // This calls DestroyPrerenderForChildRouteIdPair().
   prerender_tracker()->OnPrerenderingFinished(0, 0);
   EXPECT_TRUE(prerender_tracker()->IsPrerenderingOnIOThread(0, 0));
 
@@ -152,7 +152,7 @@ TEST_F(PrerenderTrackerTest, PrerenderTrackerCancelled) {
       0, 0, FINAL_STATUS_TIMED_OUT));
   EXPECT_EQ(FINAL_STATUS_HTTPS, GetCurrentStatus(0, 0));
 
-  // This calls DestroyPreloadForChildRouteIdPair().
+  // This calls DestroyPrerenderForChildRouteIdPair().
   RunEvents();
   EXPECT_TRUE(prerender_manager()->WasPrerenderCancelled(0, 0));
 
@@ -192,7 +192,7 @@ TEST_F(PrerenderTrackerTest, PrerenderTrackerCancelledOnIO) {
       0, 0, FINAL_STATUS_HTTPS));
   EXPECT_EQ(FINAL_STATUS_TIMED_OUT, GetCurrentStatus(0, 0));
 
-  // This calls DestroyPreloadForChildRouteIdPair().
+  // This calls DestroyPrerenderForChildRouteIdPair().
   RunEvents();
   EXPECT_TRUE(prerender_manager()->WasPrerenderCancelled(0, 0));
 
@@ -224,7 +224,7 @@ TEST_F(PrerenderTrackerTest, PrerenderTrackerCancelledFast) {
   EXPECT_TRUE(prerender_tracker()->TryCancel(0, 0, FINAL_STATUS_TIMED_OUT));
 
   // This calls AddPrerenderOnIOThreadTask() and
-  // DestroyPreloadForChildRouteIdPair().
+  // DestroyPrerenderForChildRouteIdPair().
   RunEvents();
   EXPECT_TRUE(prerender_manager()->WasPrerenderCancelled(0, 0));
 
@@ -275,7 +275,7 @@ TEST_F(PrerenderTrackerTest, PrerenderTrackerMultiple) {
   EXPECT_TRUE(prerender_tracker()->TryCancel(1, 2, FINAL_STATUS_HTTPS));
   EXPECT_EQ(FINAL_STATUS_HTTPS, GetCurrentStatus(1, 2));
 
-  // This calls DestroyPreloadForChildRouteIdPair().
+  // This calls DestroyPrerenderForChildRouteIdPair().
   RunEvents();
   EXPECT_FALSE(prerender_manager()->WasPrerenderCancelled(0, 0));
   EXPECT_TRUE(prerender_manager()->WasPrerenderCancelled(1, 2));
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 5b22575..c6a77c2 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -1700,6 +1700,8 @@
         'browser/prerender/prerender_manager.h',
         'browser/prerender/prerender_observer.cc',
         'browser/prerender/prerender_observer.h',
+        'browser/prerender/prerender_origin.cc',
+        'browser/prerender/prerender_origin.h',
         'browser/prerender/prerender_render_view_host_observer.cc',
         'browser/prerender/prerender_render_view_host_observer.h',
         'browser/prerender/prerender_tracker.cc',
diff --git a/chrome/common/chrome_switches.cc b/chrome/common/chrome_switches.cc
index 4077b6a..9d85e1d 100644
--- a/chrome/common/chrome_switches.cc
+++ b/chrome/common/chrome_switches.cc
@@ -779,6 +779,10 @@ const char kPreloadInstantSearch[]          = "preload-instant-search";
 // Controls speculative prerendering of pages, and content prefetching.  Both
 // are dispatched from <link rel=prefetch href=...> elements.
 const char kPrerender[]                     = "prerender";
+// Trigger prerendering of pages from suggestions in the omnibox. Only has an
+// effect when Instant is either disabled or restricted to search, and when
+// prerender is enabled.
+const char kPrerenderFromOmnibox[]          = "prerender-from-omnibox";
 // These are the values the switch may have, as in "--prerender=auto".
 //   auto: Allow field trial selection in both prerender and prefetch.
 const char kPrerenderSwitchValueAuto[]      = "auto";
diff --git a/chrome/common/chrome_switches.h b/chrome/common/chrome_switches.h
index bea468a..7fb5c96 100644
--- a/chrome/common/chrome_switches.h
+++ b/chrome/common/chrome_switches.h
@@ -217,6 +217,7 @@ extern const char kParentProfile[];
 extern const char kPpapiFlashInProcess[];
 extern const char kPreloadInstantSearch[];
 extern const char kPrerender[];
+extern const char kPrerenderFromOmnibox[];
 extern const char kPrerenderSwitchValueAuto[];
 extern const char kPrerenderSwitchValueDisabled[];
 extern const char kPrerenderSwitchValueEnabled[];