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 210 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());
@@ skipping 15 matching lines @@
     session_storage_namespace =
         source_web_contents->GetController()
             .GetDefaultSessionStorageNamespace();
   }
 
   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(), origin,
           url, referrer, size);
       return prerender_handle;
     }
   }
 
-  return AddPrerender(origin, process_id, url, referrer, size,
+  return AddPrerender(origin, process_id, prerender_id, url, referrer, size,
                       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,
                       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 607 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));
   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_CROSSDOMAIN ||
@@ skipping 65 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