Add PrerenderStatusEvent on Prerenders

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 <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
@@ skipping 194 matching lines @@
 
 PrerenderManager::~PrerenderManager() {
 }
 
 void PrerenderManager::Shutdown() {
   DoShutdown();
 }
 
 PrerenderHandle* PrerenderManager::AddPrerenderFromLinkRelPrerender(
     int process_id,
+    int prerender_id,
     int route_id,
     const GURL& url,
     const content::Referrer& referrer,
     const gfx::Size& size) {
 #if defined(OS_ANDROID)
   // TODO(jcivelli): http://crbug.com/113322 We should have an option to disable
   //                link-prerender and enable omnibox-prerender only.
   return NULL;
 #else
   DCHECK(!size.IsEmpty());
   if (PrerenderData* parent_prerender_data =
           FindPrerenderDataForChildAndRoute(process_id, route_id)) {
     // Instead of prerendering from inside of a running prerender, we will defer
     // this request until its launcher is made visible.
     if (PrerenderContents* contents = parent_prerender_data->contents_) {
-      pending_prerender_list_.push_back(
-          linked_ptr<PrerenderData>(new PrerenderData(this)));
+      pending_prerender_list_.push_back(linked_ptr<PrerenderData>(
+          new PrerenderData(this)));
       PrerenderHandle* prerender_handle =
           new PrerenderHandle(pending_prerender_list_.back().get());
       contents->AddPendingPrerender(
           prerender_handle->weak_ptr_factory_.GetWeakPtr(),
           url, referrer, size);
       return prerender_handle;
     }
   }
 
   // Unit tests pass in a process_id == -1.
   SessionStorageNamespace* session_storage_namespace = NULL;
   if (process_id != -1) {
     RenderViewHost* source_render_view_host =
         RenderViewHost::FromID(process_id, route_id);
     if (!source_render_view_host)
       return NULL;
     WebContents* source_web_contents =
         WebContents::FromRenderViewHost(source_render_view_host);
     if (!source_web_contents)
       return NULL;
     // TODO(ajwong): This does not correctly handle storage for isolated apps.
     session_storage_namespace =
         source_web_contents->GetController()
             .GetDefaultSessionStorageNamespace();
   }
 
   return AddPrerender(ORIGIN_LINK_REL_PRERENDER,
-                      process_id, url, referrer, size,
+                      process_id, prerender_id, url, referrer, size,

[dominich, 2012/09/12 15:21:04]

I thought the PrerenderHandle work would remove the need for any arbitrary ids
like this. This feels like a step backwards in the API.

                       session_storage_namespace);
 #endif
 }
 
 PrerenderHandle* PrerenderManager::AddPrerenderFromOmnibox(
     const GURL& url,
     SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   if (!IsOmniboxEnabled(profile_))
     return NULL;
-  return AddPrerender(ORIGIN_OMNIBOX, -1, url, content::Referrer(), size,
+  return AddPrerender(ORIGIN_OMNIBOX, -1, -1, url, content::Referrer(), size,

[dominich, 2012/09/12 15:21:04]

does this mean the renderer doesn't get informed about Omnibox prerenders? Is
that an issue?

                       session_storage_namespace);
 }
 
 void PrerenderManager::DestroyPrerenderForRenderView(
     int process_id, int view_id, FinalStatus final_status) {
   DCHECK(CalledOnValidThread());
   if (PrerenderData* prerender_data =
           FindPrerenderDataForChildAndRoute(process_id, view_id)) {
     prerender_data->contents_->Destroy(final_status);
   }
@@ skipping 542 matching lines @@
   DCHECK(existing_prerender_handle->IsValid());
   DCHECK(existing_prerender_handle->IsPending());
 
   DVLOG(6) << "StartPendingPrerender";
   DVLOG(6) << "existing_prerender_handle->handle_count_ = " <<
       existing_prerender_handle->prerender_data_->handle_count_;
 
   DCHECK(process_id == -1 || session_storage_namespace);
 
   scoped_ptr<PrerenderHandle> swap_prerender_handle(AddPrerender(
-      origin, process_id, url, referrer, size, session_storage_namespace));
+      origin, process_id, -1, url, referrer, size, session_storage_namespace));

[mmenke, 2012/09/12 16:31:45]

Won't this break PrerenderMsg_StoppedPrerender?  We'll glom all pending
prerenders into a group with an id of -1, send multiple start events for it
(Which won't get passed on to WebKit), and then when one of them stops, we'll
delete them all, renderer-side, but keep them browser-side, while WebKit remains
happily oblivious.

   if (swap_prerender_handle.get()) {
     // AddPrerender has returned a new prerender handle to us. We want to make
     // |existing_prerender_handle| active, so swap the underlying PrerenderData
     // between the two handles, and delete our old handle (which will release
     // our entry in the pending_prerender_list_).
     existing_prerender_handle->SwapPrerenderDataWith(
         swap_prerender_handle.get());
     swap_prerender_handle->OnCancel();
     return;
   }
@@ skipping 52 matching lines @@
   on_close_tab_contents_deleters_.clear();
   profile_ = NULL;
 
   DCHECK(active_prerender_list_.empty());
 }
 
 // private
 PrerenderHandle* PrerenderManager::AddPrerender(
     Origin origin,
     int process_id,
+    int prerender_id,
     const GURL& url_arg,
     const content::Referrer& referrer,
     const gfx::Size& size,
     SessionStorageNamespace* session_storage_namespace) {
   DCHECK(CalledOnValidThread());
 
   if (!IsEnabled())
     return NULL;
 
   if (origin == ORIGIN_LINK_REL_PRERENDER &&
@@ skipping 14 matching lines @@
     url = alias_url;
   }
 
   // From here on, we will record a FinalStatus so we need to register with the
   // histogram tracking.
   histograms_->RecordPrerender(origin, url_arg);
 
   if (PrerenderData* preexisting_prerender_data =
           FindPrerenderData(url, session_storage_namespace)) {
     RecordFinalStatus(origin, experiment, FINAL_STATUS_DUPLICATE);
     return new PrerenderHandle(preexisting_prerender_data);

[mmenke, 2012/09/12 16:31:45]

When we merge prerenders, only one of them will ever get updates.

   }
 
   // Do not prerender if there are too many render processes, and we would
   // have to use an existing one.  We do not want prerendering to happen in
   // a shared process, so that we can always reliably lower the CPU
   // priority for prerendering.
   // In single-process mode, ShouldTryToUseExistingProcessHost() always returns
   // true, so that case needs to be explicitly checked for.
   // TODO(tburkard): Figure out how to cancel prerendering in the opposite
   // case, when a new tab is added to a process used for prerendering.
@@ skipping 29 matching lines @@
       this, prerender_contents, GetExpiryTimeForNewPrerender())));
 
   PrerenderHandle* prerender_handle =
       new PrerenderHandle(active_prerender_list_.back().get());
 
   last_prerender_start_time_ = GetCurrentTimeTicks();
 
   gfx::Size contents_size =
       size.IsEmpty() ? config_.default_tab_bounds.size() : size;
 
-  prerender_contents->StartPrerendering(process_id, contents_size,
+  prerender_contents->StartPrerendering(process_id, prerender_id, contents_size,
                                         session_storage_namespace,
                                         control_group_behavior);
 
   while (active_prerender_list_.size() > config_.max_concurrency) {
     prerender_contents = active_prerender_list_.front()->contents_;
     DCHECK(prerender_contents);
     prerender_contents->Destroy(FINAL_STATUS_EVICTED);
   }
 
   histograms_->RecordConcurrency(active_prerender_list_.size(),
@@ skipping 287 matching lines @@
   if (!render_process_host || !render_process_host->GetBrowserContext())
     return NULL;
   Profile* profile = Profile::FromBrowserContext(
       render_process_host->GetBrowserContext());
   if (!profile)
     return NULL;
   return PrerenderManagerFactory::GetInstance()->GetForProfile(profile);
 }
 
 }  // namespace prerender