Add PrerenderStatusEvent on Prerenders

chrome/renderer/prerender/prerender_dispatcher.cc

Index: chrome/renderer/prerender/prerender_dispatcher.cc
diff --git a/chrome/renderer/prerender/prerender_dispatcher.cc b/chrome/renderer/prerender/prerender_dispatcher.cc
index c5af1cd2124095a1d99b2ee37fa710cc438416a6..5ddd15bf0d3624d8a034e1a0d3fea56d7766bc79 100644
--- a/chrome/renderer/prerender/prerender_dispatcher.cc
+++ b/chrome/renderer/prerender/prerender_dispatcher.cc
@@ -6,61 +6,123 @@
 
 #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