Prerendering: Add MatchComplete PPLT

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/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 112 matching lines @@
 
 // static
 bool PrerenderManager::IsPrerenderingPossible() {
   return GetMode() == PRERENDER_MODE_ENABLED ||
          GetMode() == PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP ||
          GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP ||
          GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
 }
 
 // static
+bool PrerenderManager::ActuallyPrerendering() {
+  return IsPrerenderingPossible() && !IsControlGroup();
+}
+
+// static
 bool PrerenderManager::IsControlGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP;
 }
 
 // static
 bool PrerenderManager::IsValidHttpMethod(const std::string& method) {
   // method has been canonicalized to upper case at this point so we can just
   // compare them.
   DCHECK_EQ(method, StringToUpperASCII(method));
   for (size_t i = 0; i < arraysize(kValidHttpMethods); ++i) {
@@ skipping 235 matching lines @@
     }
   }
 
   if (!session_storage_namespace && source_render_view_host) {
     session_storage_namespace =
         source_render_view_host->session_storage_namespace();
   }
 
   PrerenderContents* prerender_contents = CreatePrerenderContents(
       url, referrer, origin, experiment);
-  if (!prerender_contents || !prerender_contents->Init())
+  if (!prerender_contents || !prerender_contents->Init()) {
+    if (prerender_contents)
+      delete prerender_contents;
     return false;
+  }
 
   // TODO(cbentzel): Move invalid checks here instead of PrerenderContents?
   PrerenderContentsData data(prerender_contents, GetCurrentTime());
 
   prerender_list_.push_back(data);
 
   if (IsControlGroup()) {
     data.contents_->set_final_status(FINAL_STATUS_CONTROL_GROUP);
   } else {
     last_prerender_start_time_ = GetCurrentTimeTicks();
@@ skipping 240 matching lines @@
     // No unload handler to run, so delete asap.
     ScheduleDeleteOldTabContents(old_tab_contents, NULL);
   }
 
   // TODO(cbentzel): Should prerender_contents move to the pending delete
   //                 list, instead of deleting directly here?
   AddToHistory(prerender_contents.get());
   return true;
 }
 
-void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry) {
+bool PrerenderManager::NeedMatchCompleteDummyForFinalStatus(
+    FinalStatus final_status) const {
+  return final_status != FINAL_STATUS_USED &&
+      final_status != FINAL_STATUS_TIMED_OUT &&
+      final_status != FINAL_STATUS_EVICTED &&
+      final_status != FINAL_STATUS_MANAGER_SHUTDOWN &&
+      final_status != FINAL_STATUS_WINDOW_OPENER &&
+      final_status != FINAL_STATUS_FRAGMENT_MISMATCH &&
+      final_status != FINAL_STATUS_CACHE_OR_HISTORY_CLEARED &&
+      final_status != FINAL_STATUS_CANCELLED &&
+      final_status != FINAL_STATUS_MATCH_COMPLETE_DUMMY;
+}
+
+void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry,
+                                                FinalStatus final_status) {
   DCHECK(CalledOnValidThread());
+  DCHECK(entry);
   DCHECK(!IsPendingDelete(entry));
+
+  // If this PrerenderContents is being deleted due to a cancellation, we need
+  // to create a dummy replacement for PPLT accounting purposes for the
+  // Match Complete group.
+  // This is the case if the cancellation is for any reason that would not occur
+  // in the control group case.
+  PrerenderContents* dummy_replacement_prerender_contents = NULL;
+  if (NeedMatchCompleteDummyForFinalStatus(final_status)) {
+    // TODO(tburkard): I'd like to DCHECK that we are actually prerendering.
+    // However, what if new conditions are added and
+    // NeedMatchCompleteDummyForFinalStatus, is not being updated.  Not sure
+    // what's the best thing to do here.  For now, I will just check whether
+    // we are actually prerendering.
+    if (ActuallyPrerendering()) {
+      dummy_replacement_prerender_contents = CreatePrerenderContents(
+          entry->prerender_url(),
+          entry->referrer(),
+          entry->origin(),
+          entry->experiment_id());
+      if (dummy_replacement_prerender_contents) {
+        if (!dummy_replacement_prerender_contents->Init()) {
+          delete dummy_replacement_prerender_contents;
+          dummy_replacement_prerender_contents = NULL;
+        }
+      }
+    }
+  }
+
   for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
        it != prerender_list_.end();
        ++it) {
     if (it->contents_ == entry) {
-      prerender_list_.erase(it);
+      if (dummy_replacement_prerender_contents) {
+        it->contents_ = dummy_replacement_prerender_contents;
+        it->contents_->set_final_status(FINAL_STATUS_MATCH_COMPLETE_DUMMY);
+      } else {
+        prerender_list_.erase(it);
+      }
       break;
     }
   }
   AddToHistory(entry);
   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 51 matching lines @@
     const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrerenderManager* prerender_manager =
       PrerenderManagerFactory::GetForProfile(
           Profile::FromBrowserContext(tab_contents->browser_context()));
   if (!prerender_manager)
     return;
   if (!prerender_manager->is_enabled())
     return;
   bool was_prerender =
-      ((mode_ == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP &&
-        prerender_manager->WouldTabContentsBePrerendered(tab_contents)) ||
-       (mode_ == PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP &&
-        prerender_manager->IsTabContentsPrerendered(tab_contents)));
+      prerender_manager->IsTabContentsPrerendered(tab_contents);
+  bool was_complete_prerender = was_prerender ||
+      prerender_manager->WouldTabContentsBePrerendered(tab_contents);
   prerender_manager->histograms_->RecordPerceivedPageLoadTime(
-      perceived_page_load_time, was_prerender, url);
+      perceived_page_load_time, was_prerender, was_complete_prerender, url);
 }
 
 bool PrerenderManager::is_enabled() const {
   DCHECK(CalledOnValidThread());
   if (!enabled_)
     return false;
   for (std::list<const PrerenderCondition*>::const_iterator it =
            prerender_conditions_.begin();
        it != prerender_conditions_.end();
        ++it) {
@@ skipping 300 matching lines @@
   if (!render_process_host || !render_process_host->browser_context())
     return NULL;
   Profile* profile = Profile::FromBrowserContext(
       render_process_host->browser_context());
   if (!profile)
     return NULL;
   return PrerenderManagerFactory::GetInstance()->GetForProfile(profile);
 }
 
 }  // namespace prerender