Prerender: NoStatePrefetch browser side changes.

chrome/browser/prerender/prerender_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_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 303 matching lines @@
   // First, try to find prerender data with the correct session storage
   // namespace.
   // TODO(ajwong): This doesn't handle isolated apps correctly.
   PrerenderData* prerender_data = FindPrerenderData(
       url,
       web_contents->GetController().GetDefaultSessionStorageNamespace());
   if (!prerender_data)
     return false;
   DCHECK(prerender_data->contents());
 
+  if (prerender_data->contents()->prerender_mode() != FULL_PRERENDER)
+    return false;
+
   std::unique_ptr<WebContents> new_web_contents = SwapInternal(
       url, web_contents, prerender_data, params->should_replace_current_entry);
   if (!new_web_contents)
     return false;
 
   // Record the new target_contents for the callers.
   params->target_contents = new_web_contents.release();
   return true;
 }
 
@@ skipping 231 matching lines @@
     case PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP:
       return "_Enabled";
     case PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP:
       return "_Control";
     case PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP:
       return "_Multi";
     case PRERENDER_MODE_EXPERIMENT_15MIN_TTL_GROUP:
       return "_15MinTTL";
     case PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP:
       return "_NoUse";
+    case PRERENDER_MODE_NOSTATE_PREFETCH:
+      return "_NoStatePrefetch";
     case PRERENDER_MODE_MAX:
     default:
       NOTREACHED() << "Invalid PrerenderManager mode.";
       break;
   }
   return "";
 }
 
 // static
 bool PrerenderManager::IsPrerenderingPossible() {
   return GetMode() != PRERENDER_MODE_DISABLED;
 }
 
 // static
 bool PrerenderManager::ActuallyPrerendering() {
   return IsPrerenderingPossible() && !IsControlGroup();
 }
 
 // static
 bool PrerenderManager::IsControlGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP;
 }
 
 // static
 bool PrerenderManager::IsNoUseGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
 }
 
+// static
+bool PrerenderManager::IsNoStatePrefetch() {
+  return GetMode() == PRERENDER_MODE_NOSTATE_PREFETCH;
+}
+
 bool PrerenderManager::IsWebContentsPrerendering(
     const WebContents* web_contents,
     Origin* origin) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrerenderContents* prerender_contents = GetPrerenderContents(web_contents);
   if (!prerender_contents)
     return false;
 
   if (origin)
     *origin = prerender_contents->origin();
@@ skipping 57 matching lines @@
     int route_id) const {
   WebContents* web_contents = tab_util::GetWebContentsByID(child_id, route_id);
   return web_contents ? GetPrerenderContents(web_contents) : nullptr;
 }
 
 std::vector<WebContents*> PrerenderManager::GetAllPrerenderingContents() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::vector<WebContents*> result;
 
   for (const auto& prerender : active_prerenders_) {
-    if (WebContents* contents = prerender->contents()->prerender_contents())
+    WebContents* contents = prerender->contents()->prerender_contents();
+    if (contents &&
+        prerender->contents()->prerender_mode() == FULL_PRERENDER) {
       result.push_back(contents);
+    }
   }
 
   return result;
 }
 
 bool PrerenderManager::HasRecentlyBeenNavigatedTo(Origin origin,
                                                   const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   CleanUpOldNavigations();
@@ skipping 237 matching lines @@
     // by a navigation and is unlikely to be the same site.
     RecordFinalStatusWithoutCreatingPrerenderContents(
         url, origin, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return nullptr;
   }
 
   std::unique_ptr<PrerenderContents> prerender_contents =
       CreatePrerenderContents(url, referrer, origin);
   DCHECK(prerender_contents);
   PrerenderContents* prerender_contents_ptr = prerender_contents.get();
+  if (IsNoStatePrefetch())
+    prerender_contents_ptr->SetPrerenderMode(PREFETCH_ONLY);
   active_prerenders_.push_back(
       base::MakeUnique<PrerenderData>(this, std::move(prerender_contents),
                                       GetExpiryTimeForNewPrerender(origin)));
   if (!prerender_contents_ptr->Init()) {
     DCHECK(active_prerenders_.end() ==
            FindIteratorForPrerenderContents(prerender_contents_ptr));
     return nullptr;
   }
 
   histograms_->RecordPrerenderStarted(origin);
@@ skipping 342 matching lines @@
   DCHECK_EQ(1u, erased);
 }
 
 void PrerenderManager::SetPrerenderContentsFactoryForTest(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 }  // namespace prerender