Handle interface to prerenders.

chrome/browser/prerender/prerender_link_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_link_manager.h"
 
 #include <limits>
 #include <queue>
 #include <utility>
 
+#include "base/basictypes.h"

[gavinp, 2012/07/14 22:12:30]

Whoops. I'll fix this shortly.

 #include "chrome/browser/prerender/prerender_contents.h"
+#include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/common/referrer.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "ui/gfx/size.h"
 
 using content::RenderViewHost;
 using content::SessionStorageNamespace;
 
 namespace prerender {
 
 PrerenderLinkManager::PrerenderLinkManager(PrerenderManager* manager)
     : manager_(manager) {
 }
 
 PrerenderLinkManager::~PrerenderLinkManager() {
+  for (IdPairToPrerenderHandleMap::iterator it = ids_to_handle_map_.begin();
+       it != ids_to_handle_map_.end();
+       ++it) {
+    PrerenderHandle* prerender_handle = it->second;
+    prerender_handle->OnCancel();
+    delete prerender_handle;
+  }
 }
 
 bool PrerenderLinkManager::OnAddPrerender(int child_id,
                                           int prerender_id,
                                           const GURL& orig_url,
                                           const content::Referrer& referrer,
                                           const gfx::Size& size,
                                           int render_view_route_id) {
   DVLOG(2) << "OnAddPrerender, child_id = " << child_id
            << ", prerender_id = " << prerender_id
            << ", url = " << orig_url.spec();
   DVLOG(3) << "... referrer url = " << referrer.url.spec()
            << ", size = (" << size.width() << ", " << size.height() << ")"
            << ", render_view_route_id = " << render_view_route_id;
 
+  const ChildAndPrerenderIdPair child_and_prerender_id(child_id, prerender_id);
+  DCHECK_EQ(0U, ids_to_handle_map_.count(child_and_prerender_id));
+
   // TODO(gavinp): Add tests to ensure fragments work, then remove this fragment
   // clearing code.
   url_canon::Replacements<char> replacements;
   replacements.ClearRef();
   const GURL url = orig_url.ReplaceComponents(replacements);
 
-  if (!manager_->AddPrerenderFromLinkRelPrerender(
-          child_id, render_view_route_id, url, referrer, size)) {
-    return false;
+  scoped_ptr<PrerenderHandle> prerender_handle(
+      manager_->AddPrerenderFromLinkRelPrerender(
+          child_id, render_view_route_id, url, referrer, size));
+  if (prerender_handle.get()) {
+    PrerenderHandle* null = NULL;
+    std::pair<IdPairToPrerenderHandleMap::iterator, bool> insert_result =
+        ids_to_handle_map_.insert(IdPairToPrerenderHandleMap::value_type(
+            child_and_prerender_id, null));

[gavinp, 2012/07/14 21:15:33]

The windows try bots were OK with this, but something is different in some
windows builders, and the pair type constructor will not accept NULL, or even
implicit_cast<PrererenderHandle*>(NULL). I suppose
implicit_cast<PrerenderHandle*const&>(NULL) would have worked, but that kinda
makes me sick.

[Peter Kasting, 2012/07/14 21:53:34]

Did you try std::make_pair?

[gavinp, 2012/07/14 22:12:30]

Yes, with that it won't compile in clang or gcc. I've had very bad luck with
std::make_pair() where there's NULLs involved. Probably coincidentally, the
instance of NULL is like this:

  std::make_pair(foo, static_cast<Bar*>(NULL));

Which works too. Would you prefer that? I don't like using static_cast<>, but I
also don't like "null".

[Peter Kasting, 2012/07/15 00:50:15]

That seems slightly better to me.  We have to static_cast NULL in some other
places too.

I wonder if C++11's nullptr would help here...

+    DCHECK(insert_result.second);
+    delete insert_result.first->second;
+    insert_result.first->second = prerender_handle.release();
+    return true;
   }
-  const ChildAndPrerenderIdPair child_and_prerender_id(child_id, prerender_id);
-  DCHECK_EQ(0U, ids_to_url_map_.count(child_and_prerender_id));
-  ids_to_url_map_.insert(std::make_pair(child_and_prerender_id, url));
-  return true;
+  return false;
 }
 
 // TODO(gavinp): Once an observer interface is provided down to the WebKit
 // layer, we should add DCHECK_NE(0L, ids_to_url_map_.count(...)) to both
 // OnCancelPrerender and OnAbandonPrerender. We can't do this now, since
 // the WebKit layer isn't even aware if we didn't add the prerender to the map
 // in OnAddPrerender above.
 void PrerenderLinkManager::OnCancelPrerender(int child_id, int prerender_id) {
   DVLOG(2) << "OnCancelPrerender, child_id = " << child_id
            << ", prerender_id = " << prerender_id;
   const ChildAndPrerenderIdPair child_and_prerender_id(child_id, prerender_id);
-  IdPairToUrlMap::iterator id_url_iter =
-      ids_to_url_map_.find(child_and_prerender_id);
-  if (id_url_iter == ids_to_url_map_.end()) {
+  IdPairToPrerenderHandleMap::iterator id_to_handle_iter =
+      ids_to_handle_map_.find(child_and_prerender_id);
+  if (id_to_handle_iter == ids_to_handle_map_.end()) {
     DVLOG(5) << "... canceling a prerender that doesn't exist.";
     return;
   }
-  const GURL url = id_url_iter->second;
-  ids_to_url_map_.erase(id_url_iter);
-  manager_->MaybeCancelPrerender(url);
+  PrerenderHandle* prerender_handle = id_to_handle_iter->second;
+  prerender_handle->OnCancel();
+  RemovePrerender(id_to_handle_iter);
 }
 
 void PrerenderLinkManager::OnAbandonPrerender(int child_id, int prerender_id) {
   DVLOG(2) << "OnAbandonPrerender, child_id = " << child_id
            << ", prerender_id = " << prerender_id;
-  // TODO(gavinp,cbentzel): Implement reasonable behaviour for
-  // navigation away from launcher.
   const ChildAndPrerenderIdPair child_and_prerender_id(child_id, prerender_id);
-  ids_to_url_map_.erase(child_and_prerender_id);
+  IdPairToPrerenderHandleMap::iterator id_to_handle_iter =
+      ids_to_handle_map_.find(child_and_prerender_id);
+  if (id_to_handle_iter == ids_to_handle_map_.end())
+    return;
+  PrerenderHandle* prerender_handle = id_to_handle_iter->second;
+  prerender_handle->OnNavigateAway();
+  RemovePrerender(id_to_handle_iter);
 }
 
 void PrerenderLinkManager::OnChannelClosing(int child_id) {
   DVLOG(2) << "OnChannelClosing, child id = " << child_id;
   const ChildAndPrerenderIdPair child_and_minimum_prerender_id(
       child_id, std::numeric_limits<int>::min());
   const ChildAndPrerenderIdPair child_and_maximum_prerender_id(
       child_id, std::numeric_limits<int>::max());
   std::queue<int> prerender_ids_to_abandon;
-  for (IdPairToUrlMap::iterator
-           i = ids_to_url_map_.lower_bound(child_and_minimum_prerender_id),
-           e = ids_to_url_map_.upper_bound(child_and_maximum_prerender_id);
+  for (IdPairToPrerenderHandleMap::iterator
+           i = ids_to_handle_map_.lower_bound(child_and_minimum_prerender_id),
+           e = ids_to_handle_map_.upper_bound(child_and_maximum_prerender_id);
        i != e; ++i) {
     prerender_ids_to_abandon.push(i->first.second);
   }
   while (!prerender_ids_to_abandon.empty()) {
     DVLOG(4) << "---> abandon prerender_id = "
              << prerender_ids_to_abandon.front();
     OnAbandonPrerender(child_id, prerender_ids_to_abandon.front());
     prerender_ids_to_abandon.pop();
   }
 }
 
 bool PrerenderLinkManager::IsEmpty() const {
-  return ids_to_url_map_.empty();
+  return ids_to_handle_map_.empty();
+}
+
+void PrerenderLinkManager::RemovePrerender(
+    const IdPairToPrerenderHandleMap::iterator& id_to_handle_iter) {
+  PrerenderHandle* prerender_handle = id_to_handle_iter->second;
+  delete prerender_handle;
+  ids_to_handle_map_.erase(id_to_handle_iter);
 }
 
 }  // namespace prerender
-