Added prerendering to omnibox.

chrome/browser/prerender/prerender_manager.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/prerender/prerender_manager.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 204 matching lines @@
     const GURL& referrer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
   if (!prerender_manager || !prerender_manager->is_enabled())
     return;
   prerender_manager->RecordTagObserved();
 
   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->AddPrerender(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,
     FinalStatus final_status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
   if (!prerender_manager)
     return;
 
-  prerender_manager->DestroyPreloadForChildRouteIdPair(
+  prerender_manager->DestroyPrerenderForChildRouteIdPair(
       std::make_pair(render_process_id, render_view_id),
       final_status);
 }
 
 PrerenderManager::PrerenderManager(Profile* profile,
                                    PrerenderTracker* prerender_tracker)
     : rate_limit_enabled_(true),
       enabled_(true),
       profile_(profile),
       prerender_tracker_(prerender_tracker),
@@ skipping 20 matching lines @@
   }
   DeletePendingDeleteEntries();
 }
 
 void PrerenderManager::SetPrerenderContentsFactory(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK(CalledOnValidThread());
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
-bool PrerenderManager::AddPreload(
+bool PrerenderManager::AddPrerender(
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url_arg,
     const GURL& referrer) {
   DCHECK(CalledOnValidThread());
 
   // 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(child_route_id_pair, url_arg, referrer);
     return true;
   }
 
   DeleteOldEntries();
   DeletePendingDeleteEntries();
 
   GURL url = url_arg;
   GURL alias_url;
   if (IsControlGroup() &&
       PrerenderManager::MaybeGetQueryStringBasedAliasURL(
@@ skipping 58 matching lines @@
   }
   while (prerender_list_.size() > max_elements_) {
     data = prerender_list_.front();
     prerender_list_.pop_front();
     data.contents_->Destroy(FINAL_STATUS_EVICTED);
   }
   StartSchedulingPeriodicCleanups();
   return true;
 }
 
-void PrerenderManager::AddPendingPreload(
+bool PrerenderManager::AddPrerenderWithNoTag(const GURL& url) {
+  return AddPrerender(std::make_pair(-1, -1), url, GURL());
+}
+
+void PrerenderManager::AddPendingPrerender(
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url,
     const GURL& referrer) {
   DCHECK(FindPrerenderContentsForChildRouteIdPair(child_route_id_pair) !=
              prerender_list_.end());
   PendingPrerenderList::iterator it =
       pending_prerender_list_.find(child_route_id_pair);
   if (it == pending_prerender_list_.end()) {
     PendingPrerenderList::value_type el = std::make_pair(child_route_id_pair,
                                             std::vector<PendingContentsData>());
@@ skipping 18 matching lines @@
 
     if (has_child_id && has_route_id &&
         child_id == child_route_id_pair.first &&
         route_id == child_route_id_pair.second) {
       break;
     }
   }
   return it;
 }
 
-void PrerenderManager::DestroyPreloadForChildRouteIdPair(
+void PrerenderManager::DestroyPrerenderForChildRouteIdPair(
     const std::pair<int, int>& child_route_id_pair,
     FinalStatus final_status) {
   DCHECK(CalledOnValidThread());
   std::list<PrerenderContentsData>::iterator it =
       FindPrerenderContentsForChildRouteIdPair(child_route_id_pair);
   if (it != prerender_list_.end()) {
     PrerenderContents* prerender_contents = it->contents_;
     prerender_contents->Destroy(final_status);
   }
 }
@@ skipping 29 matching lines @@
     }
   }
   // Entry not found.
   return NULL;
 }
 
 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));
   if (prerender_contents.get() == NULL)
     return false;
 
   // Do not use the prerendered version if the opener window.property was
   // supposed to be set.
   if (has_opener_set) {
     prerender_contents.release()->Destroy(FINAL_STATUS_WINDOW_OPENER);
@@ skipping 84 matching lines @@
 
   // See if we have any pending prerender requests for this routing id and start
   // the preload if we do.
   std::pair<int, int> child_route_pair = std::make_pair(child_id, route_id);
   PendingPrerenderList::iterator pending_it =
       pending_prerender_list_.find(child_route_pair);
   if (pending_it != pending_prerender_list_.end()) {
     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_);
+      AddPrerender(pending_it->first, content_it->url_, content_it->referrer_);
     }
     pending_prerender_list_.erase(pending_it);
   }
 
   if (old_tab_contents->tab_contents()->NeedToFireBeforeUnload()) {
     // Schedule the delete to occur after the tab has run its unload handlers.
     on_close_tab_contents_deleters_.push_back(
         new OnCloseTabContentsDeleter(this, old_tab_contents));
     old_tab_contents->render_view_host()->FirePageBeforeUnload(false);
   } else {
     // No unload handler to run, so delete asap.
     ScheduleDeleteOldTabContents(old_tab_contents, NULL);
   }
   return true;
 }
 
 void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry) {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsPendingDelete(entry));
   for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
        it != prerender_list_.end();
        ++it) {
     if (it->contents_ == entry) {
-      RemovePendingPreload(entry);
+      RemovePendingPrerender(entry);
       prerender_list_.erase(it);
       break;
     }
   }
   pending_delete_list_.push_back(entry);
 
   // Destroy the old TabContents relatively promptly to reduce resource usage,
   // and in the case of HTML5 media, reduce the change of playing any sound.
   PostCleanupTask();
 }
@@ skipping 162 matching lines @@
 
 void PrerenderManager::RecordTagObserved() {
   DCHECK(CalledOnValidThread());
 
   // If we observe multiple tags within the 30 second window, we will still
   // reset the window to begin at the most recent occurrence, so that we will
   // always be in a window in the 30 seconds from each occurrence.
   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;
   bool has_child_id = entry->GetChildId(&child_id);
   bool has_route_id = has_child_id && entry->GetRouteId(&route_id);
 
   // If the entry doesn't have a RenderViewHost then it didn't start
   // prerendering and there shouldn't be any pending preloads to remove.
   if (has_child_id && has_route_id) {
     std::pair<int, int> child_route_pair = std::make_pair(child_id, route_id);
@@ skipping 196 matching lines @@
     ScopedVector<OnCloseTabContentsDeleter>::iterator i = std::find(
         on_close_tab_contents_deleters_.begin(),
         on_close_tab_contents_deleters_.end(),
         deleter);
     DCHECK(i != on_close_tab_contents_deleters_.end());
     on_close_tab_contents_deleters_.erase(i);
   }
 }
 
 }  // namespace prerender