Add <link rel=next> support to prerender.

chrome/browser/prerender/prerender_link_manager.cc

 // Copyright (c) 2012 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_link_manager.h"
 
 #include <limits>
 #include <set>
+#include <string>
 #include <utility>
 
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/field_trial.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/prerender_messages.h"
+#include "chrome/common/prerender_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/common/referrer.h"
 #include "ui/gfx/size.h"
 #include "url/gurl.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using content::RenderViewHost;
 using content::SessionStorageNamespace;
 
 namespace {
 
+bool ShouldStartRelNextPrerenders() {
+  const std::string experiment_name =
+      base::FieldTrialList::FindFullName("PrerenderRelNextTrial");
+  return experiment_name.find("Yes") != std::string::npos;
+}
+
 void Send(int child_id, IPC::Message* raw_message) {
   using content::RenderProcessHost;
   scoped_ptr<IPC::Message> own_message(raw_message);
 
   RenderProcessHost* render_process_host = RenderProcessHost::FromID(child_id);
   if (!render_process_host)
     return;
   render_process_host->Send(own_message.release());
 }
 
 }  // namespace
 
 namespace prerender {
 
 PrerenderLinkManager::PrerenderLinkManager(PrerenderManager* manager)
-    : has_shutdown_(false),
+    : should_start_rel_next_prerenders_(ShouldStartRelNextPrerenders()),
+      has_shutdown_(false),
       manager_(manager) {
 }
 
 PrerenderLinkManager::~PrerenderLinkManager() {
   for (std::list<LinkPrerender>::iterator i = prerenders_.begin();
        i != prerenders_.end(); ++i) {
     if (i->handle) {
       DCHECK(!i->handle->IsPrerendering())
           << "All running prerenders should stop at the same time as the "
           << "PrerenderManager.";
       delete i->handle;
       i->handle = 0;
     }
   }
 }
 
 void PrerenderLinkManager::OnAddPrerender(int launcher_child_id,
                                           int prerender_id,
                                           const GURL& url,
+                                          uint32 rel_types,
                                           const content::Referrer& referrer,
                                           const gfx::Size& size,
                                           int render_view_route_id) {
   DCHECK_EQ(static_cast<LinkPrerender*>(NULL),
             FindByLauncherChildIdAndPrerenderId(launcher_child_id,
                                                 prerender_id));
   content::RenderProcessHost* rph =
       content::RenderProcessHost::FromID(launcher_child_id);
   // Guests inside <webview> do not support cross-process navigation and so we
   // do not allow guests to prerender content.
   if (rph && rph->IsGuest())
     return;
 
   LinkPrerender
-      prerender(launcher_child_id, prerender_id, url, referrer, size,
+      prerender(launcher_child_id, prerender_id, url, rel_types, referrer, size,
                 render_view_route_id, manager_->GetCurrentTimeTicks());
   prerenders_.push_back(prerender);
   StartPrerenders();
 }
 
 void PrerenderLinkManager::OnCancelPrerender(int child_id, int prerender_id) {
   LinkPrerender* prerender = FindByLauncherChildIdAndPrerenderId(child_id,
                                                                  prerender_id);
   if (!prerender)
     return;
@@ skipping 36 matching lines @@
     const size_t running_prerender_count = CountRunningPrerenders();
     OnAbandonPrerender(child_id, it->prerender_id);
     DCHECK_EQ(running_prerender_count, CountRunningPrerenders());
   }
 }
 
 PrerenderLinkManager::LinkPrerender::LinkPrerender(
     int launcher_child_id,
     int prerender_id,
     const GURL& url,
+    uint32 rel_types,
     const content::Referrer& referrer,
     const gfx::Size& size,
     int render_view_route_id,
     TimeTicks creation_time) : launcher_child_id(launcher_child_id),
                                prerender_id(prerender_id),
                                url(url),
+                               rel_types(rel_types),
                                referrer(referrer),
                                size(size),
                                render_view_route_id(render_view_route_id),
                                creation_time(creation_time),
                                handle(NULL),
                                is_match_complete_replacement(false),
                                has_been_abandoned(false) {
 }
 
 PrerenderLinkManager::LinkPrerender::~LinkPrerender() {
@@ skipping 86 matching lines @@
       // an abandoned prerender to make room?
       if (!abandoned_prerenders.empty()) {
         CancelPrerender(abandoned_prerenders.front());
         --total_started_prerender_count;
         abandoned_prerenders.pop_front();
       } else {
         return;
       }
     }
 
+    switch ((*i)->rel_types) {
+      case PrerenderRelTypePrerender:
+      case PrerenderRelTypePrerender | PrerenderRelTypeNext:
+        break;
+
+      case PrerenderRelTypeNext:
+        if (should_start_rel_next_prerenders_)
+          break;
+        else
+          continue;
+
+      case 0:
+      default:
+        NOTREACHED();
+    }
+

[davidben, 2013/12/19 20:30:03]

Nit: Maybe split this off into a separate function and check each bit
individually? Something like

if (!ShouldLaunchPrerender(*i))
  continue;

bool PrerenderLinkManager::ShouldLaunchPrerender(LinkPrerender* prerender) {
  DCHECK_NE(0, prerender->rel_types);
  if (prerender->rel_types & PrerenderRelTypePrerender)
    return true;
  if (should_start_rel_next_prerenders_ &&
      (prerender->rel_types & PrerenderRelTypeNext))
    return true;
  return false;
}

The switch-case on a bitmask looks a little goofy. :-) Also this way adding a
new field doesn't have to be multisided.

[gavinp, 2013/12/20 14:44:48]

Done.

     PrerenderHandle* handle = manager_->AddPrerenderFromLinkRelPrerender(
         (*i)->launcher_child_id, (*i)->render_view_route_id,
         (*i)->url, (*i)->referrer, (*i)->size);
     if (!handle) {
       // This prerender couldn't be launched, it's gone.
       prerenders_.erase(*i);
       continue;
     }
 
     // We have successfully started a new prerender.
@@ skipping 111 matching lines @@
   DCHECK(!prerender->is_match_complete_replacement);
   prerender->is_match_complete_replacement = true;
   Send(prerender->launcher_child_id,
        new PrerenderMsg_OnPrerenderStop(prerender->prerender_id));
   // Do not call RemovePrerender here. The replacement needs to stay connected
   // to the HTMLLinkElement in the renderer so it notices renderer-triggered
   // cancelations.
 }
 
 }  // namespace prerender