Add PrerenderStatusEvent on Prerenders

chrome/renderer/prerender/prerender_dispatcher.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/renderer/prerender/prerender_dispatcher.h"
 
 #include "base/logging.h"
 #include "chrome/common/prerender_messages.h"
-#include "chrome/renderer/prerender/prerendering_support.h"
+#include "chrome/renderer/prerender/prerender_extra_data.h"
+#include "content/public/common/referrer.h"
+#include "content/public/renderer/render_thread.h"
+#include "content/public/renderer/render_view.h"
 #include "googleurl/src/gurl.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebPrerenderingSupport.h"
 
 namespace prerender {
 
-PrerenderDispatcher::PrerenderDispatcher()
-    : prerendering_support_(new PrerenderingSupport()) {
-  WebKit::WebPrerenderingSupport::initialize(prerendering_support_.get());
+using WebKit::WebPrerender;
+using WebKit::WebPrerenderingSupport;
+
+PrerenderDispatcher::PrerenderDispatcher() {
+  WebPrerenderingSupport::initialize(this);
 }
 
 PrerenderDispatcher::~PrerenderDispatcher() {
-  if (prerendering_support_.get())
-    WebKit::WebPrerenderingSupport::shutdown();
+  WebPrerenderingSupport::shutdown();
 }
 
 bool PrerenderDispatcher::IsPrerenderURL(const GURL& url) const {
-  return prerender_urls_.find(url) != prerender_urls_.end();
+  for (std::map<int, WebKit::WebPrerender*>::const_iterator
+           it = prerenders_.begin();
+       it != prerenders_.end(); ++it) {
+    if (it->second->url() == url)
+      return true;
+  }
+  for (std::multimap<int, GURL>::const_iterator it = prerender_aliases_.begin();
+       it != prerender_aliases_.end(); ++it) {
+    if (it->second == url)
+      return true;
+  }
+  return false;
 }
 
 bool PrerenderDispatcher::OnControlMessageReceived(
     const IPC::Message& message) {
- bool handled = true;
+  bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrerenderDispatcher, message)
-    IPC_MESSAGE_HANDLER(PrerenderMsg_AddPrerenderURL, OnAddPrerenderURL)
-    IPC_MESSAGE_HANDLER(PrerenderMsg_RemovePrerenderURL, OnRemovePrerenderURL)
+    IPC_MESSAGE_HANDLER(PrerenderMsg_StartedPrerender, OnStartedPrerender)
+    IPC_MESSAGE_HANDLER(PrerenderMsg_AddAliasToPrerender, OnAddAliasToPrerender)
+    IPC_MESSAGE_HANDLER(PrerenderMsg_StoppedPrerender, OnStoppedPrerender)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
-void PrerenderDispatcher::OnAddPrerenderURL(const GURL& url) {
-  PrerenderMap::iterator it = prerender_urls_.find(url);
-  if (it != prerender_urls_.end()) {
-    DCHECK(it->second > 0);
-    it->second += 1;
-  } else {
-    prerender_urls_[url] = 1;
+void PrerenderDispatcher::OnStartedPrerender(int prerender_id) {
+  running_prerenders_.insert(prerender_id);
+
+  std::map<int, WebPrerender*>::iterator it = prerenders_.find(prerender_id);
+  if (it != prerenders_.end()) {

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

this would mean that we started a prerender before WebKit told us about it. That
seems unlikely - should it be a stronger error condition?

+    it->second->sendPrerenderStatusEvent(
+        WebKit::WebString::fromUTF8("started"));
   }
 }
 
-void PrerenderDispatcher::OnRemovePrerenderURL(const GURL& url) {
-  PrerenderMap::iterator it = prerender_urls_.find(url);
-  // This is possible with a spurious remove.
+void PrerenderDispatcher::OnAddAliasToPrerender(int prerender_id,
+                                                const GURL& url) {
+  prerender_aliases_.insert(

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

are there any invariants expected here - such as the prerender hasn't yet
started?

+      std::multimap<int, GURL>::value_type(prerender_id, url));
+}
+
+void PrerenderDispatcher::OnStoppedPrerender(int prerender_id) {
+  // It's possible we will receive a spurious remove, so we don't crash in that
+  // situation.
+
   // TODO(cbentzel): We'd also want to send the map of active prerenders when
   // creating a new render process, so the Add/Remove go relative to that.
   // This may not be that big of a deal in practice, since the newly created tab
   // is unlikely to go to the prerendered page.
-  if (it == prerender_urls_.end())
-    return;
-  DCHECK(it->second > 0);
-  it->second -= 1;
-  if (it->second == 0)
-    prerender_urls_.erase(it);
+
+  running_prerenders_.erase(prerender_id);
+  prerender_aliases_.erase(prerender_id);
+
+  std::map<int, WebPrerender*>::iterator it = prerenders_.find(prerender_id);
+  if (it != prerenders_.end()) {
+    it->second->sendPrerenderStatusEvent(
+        WebKit::WebString::fromUTF8("stopped"));
+  }
+}
+
+void PrerenderDispatcher::add(WebPrerender* prerender) {
+  const PrerenderExtraData& extra_data =
+      PrerenderExtraData::FromPrerender(*prerender);
+  prerenders_.insert(std::map<int, WebPrerender*>::value_type(
+      extra_data.prerender_id(), prerender));
+  content::RenderThread::Get()->Send(new PrerenderHostMsg_AddLinkRelPrerender(
+      extra_data.prerender_id(), GURL(prerender->url()),
+      content::Referrer(GURL(prerender->referrer()),
+                        prerender->referrerPolicy()),
+      extra_data.size(), extra_data.render_view_route_id()));

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

So if the same prerender is added twice, then the first one is stopped, we won't
cancel the underlying prerender, and it will still be used if the second
prerender is navigated to, but we won't be sending any prerender events for it.

Is this the behavior we want?

+}
+
+void PrerenderDispatcher::cancel(WebPrerender* prerender) {
+  const PrerenderExtraData& extra_data =
+      PrerenderExtraData::FromPrerender(*prerender);
+  std::map<int, WebPrerender*>::iterator it =
+      prerenders_.find(extra_data.prerender_id());
+  if (it != prerenders_.end())
+    prerenders_.erase(it);

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

Is the find / check / erase needed?

Doesn't just "prerenders_.erase(extra_data.prerender_id());" do the trick, here
and below?

+  content::RenderThread::Get()->Send(
+      new PrerenderHostMsg_CancelLinkRelPrerender(extra_data.prerender_id()));
+}
+
+void PrerenderDispatcher::abandon(WebPrerender* prerender) {
+  const PrerenderExtraData& extra_data =
+      PrerenderExtraData::FromPrerender(*prerender);
+  std::map<int, WebPrerender*>::iterator it =
+      prerenders_.find(extra_data.prerender_id());
+  if (it != prerenders_.end())
+    prerenders_.erase(it);
+  content::RenderThread::Get()->Send(
+      new PrerenderHostMsg_AbandonLinkRelPrerender(extra_data.prerender_id()));
 }
 
 }  // namespace prerender