Handle <link rel=prerender> in chrome.

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 148 matching lines @@
 
 struct PrerenderManager::PendingContentsData {
   PendingContentsData(const GURL& url,
                       const GURL& referrer)
       : url_(url), referrer_(referrer) { }
   ~PendingContentsData() {}
   GURL url_;
   GURL referrer_;
 };
 
-void HandlePrefetchTag(
+void HandleTag(
     const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const GURL& referrer,
     bool make_pending) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
   if (!prerender_manager || !prerender_manager->is_enabled())
     return;
-  prerender_manager->RecordPrefetchTagObserved();
+  prerender_manager->RecordTagObserved();
 
   std::pair<int, int> child_route_id_pair = std::make_pair(render_process_id,
                                                            render_view_id);
   // TODO(cbentzel): Should the decision to make pending be done on the
   //                 UI thread rather than the IO thread? The page may have
   //                 become activated at this point.
   if (make_pending)
     prerender_manager->AddPendingPreload(child_route_id_pair, url, referrer);
   else
     prerender_manager->AddPreload(child_route_id_pair, url, referrer);
@@ skipping 605 matching lines @@
          ++content_it) {
       if (content_it->url_ == url) {
         return &(*content_it);
       }
     }
   }
 
   return NULL;
 }
 
-void PrerenderManager::RecordPrefetchTagObserved() {
+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_prefetch_seen_time_ = base::TimeTicks::Now();
+  last_prerender_seen_time_ = base::TimeTicks::Now();
 }
 
 void PrerenderManager::RemovePendingPreload(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);
     pending_prerender_list_.erase(child_route_pair);
   }
 }
 
 bool PrerenderManager::WithinWindow() const {
   DCHECK(CalledOnValidThread());
-  if (last_prefetch_seen_time_.is_null())
+  if (last_prerender_seen_time_.is_null())
     return false;
   base::TimeDelta elapsed_time =
-      base::TimeTicks::Now() - last_prefetch_seen_time_;
+      base::TimeTicks::Now() - last_prerender_seen_time_;
   return elapsed_time <= base::TimeDelta::FromSeconds(kWindowDurationSeconds);
 }
 
 bool PrerenderManager::DoesRateLimitAllowPrerender() const {
   DCHECK(CalledOnValidThread());
   base::TimeDelta elapsed_time =
       GetCurrentTimeTicks() - last_prerender_start_time_;
   UMA_HISTOGRAM_TIMES("Prerender.TimeBetweenPrerenderRequests",
                       elapsed_time);
   if (!rate_limit_enabled_)
@@ skipping 148 matching lines @@
   base::TimeTicks cutoff = GetCurrentTimeTicks() -
       base::TimeDelta::FromMilliseconds(kNavigationRecordWindowMs);
   while (!navigations_.empty()) {
     if (navigations_.front().time_ > cutoff)
       break;
     navigations_.pop_front();
   }
 }
 
 }  // namespace prerender