content/test/web_contents_observer_sanity_checker.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/test/web_contents_observer_sanity_checker.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "content/browser/frame_host/render_frame_host_impl.h"
   9 #include "content/common/frame_messages.h"
  10 #include "content/public/browser/navigation_handle.h"
  11 #include "content/public/browser/render_frame_host.h"
  12 #include "content/public/browser/render_process_host.h"
  13 #include "content/public/browser/site_instance.h"
  14 #include "content/public/browser/web_contents.h"
  15 #include "content/public/browser/web_contents_observer.h"
  16 #include "net/base/net_errors.h"
  17
  18 namespace content {
  19
  20 namespace {
  21
  22 const char kWebContentsObserverSanityCheckerKey[] =
  23     "WebContentsObserverSanityChecker";
  24
  25 }  // namespace
  26
  27 // static
  28 void WebContentsObserverSanityChecker::Enable(WebContents* web_contents) {
  29   if (web_contents->GetUserData(&kWebContentsObserverSanityCheckerKey))
  30     return;
  31   web_contents->SetUserData(&kWebContentsObserverSanityCheckerKey,
  32                             new WebContentsObserverSanityChecker(web_contents));
  33 }
  34
  35 void WebContentsObserverSanityChecker::RenderFrameCreated(
  36     RenderFrameHost* render_frame_host) {
  37   CHECK(!web_contents_destroyed_);
  38   std::pair<int, int> routing_pair =
  39       std::make_pair(render_frame_host->GetProcess()->GetID(),
  40                      render_frame_host->GetRoutingID());
  41   bool frame_exists = !live_routes_.insert(routing_pair).second;
  42   deleted_routes_.erase(routing_pair);
  43
  44   if (frame_exists) {
  45     CHECK(false) << "RenderFrameCreated called more than once for routing pair:"
  46                  << Format(render_frame_host);
  47   }
  48
  49   CHECK(render_frame_host->GetProcess()->HasConnection())
  50       << "RenderFrameCreated was called for a RenderFrameHost whose render "
  51          "process is not currently live, so there's no way for the RenderFrame "
  52          "to have been created.";
  53   CHECK(
  54       static_cast<RenderFrameHostImpl*>(render_frame_host)->IsRenderFrameLive())
  55       << "RenderFrameCreated called on for a RenderFrameHost that thinks it is "
  56          "not alive.";
  57 }
  58
  59 void WebContentsObserverSanityChecker::RenderFrameDeleted(
  60     RenderFrameHost* render_frame_host) {
  61   CHECK(!web_contents_destroyed_);
  62   std::pair<int, int> routing_pair =
  63       std::make_pair(render_frame_host->GetProcess()->GetID(),
  64                      render_frame_host->GetRoutingID());
  65   bool was_live = !!live_routes_.erase(routing_pair);
  66   bool was_dead_already = !deleted_routes_.insert(routing_pair).second;
  67
  68   if (was_dead_already) {
  69     CHECK(false) << "RenderFrameDeleted called more than once for routing pair "
  70                  << Format(render_frame_host);
  71   } else if (!was_live) {
  72 // TODO(nick): Clients can easily ignore an unrecognized object, but it
  73 // would be useful from a finding-bugs perspective if we could enable this
  74 // check.
  75 #if 0
  76     CHECK(false) << "RenderFrameDeleted called for routing pair "
  77                  << Format(render_frame_host)
  78                  << " for which RenderFrameCreated was never called";
  79 #endif
  80   }
  81 }
  82
  83 void WebContentsObserverSanityChecker::RenderFrameForInterstitialPageCreated(
  84     RenderFrameHost* render_frame_host) {
  85   // TODO(nick): Record this.
  86 }
  87
  88 void WebContentsObserverSanityChecker::RenderFrameHostChanged(
  89     RenderFrameHost* old_host,
  90     RenderFrameHost* new_host) {
  91   CHECK(new_host);
  92   CHECK_NE(new_host, old_host);
  93
  94   if (old_host) {
  95     std::pair<int, int> routing_pair =
  96         std::make_pair(old_host->GetProcess()->GetID(),
  97                        old_host->GetRoutingID());
  98     bool old_did_exist = !!current_hosts_.erase(routing_pair);
  99     if (!old_did_exist) {
 100       CHECK(false)
 101           << "RenderFrameHostChanged called with old host that did not exist:"
 102           << Format(old_host);
 103     }
 104   }
 105
 106   std::pair<int, int> routing_pair =
 107       std::make_pair(new_host->GetProcess()->GetID(),
 108                      new_host->GetRoutingID());
 109   bool host_exists = !current_hosts_.insert(routing_pair).second;
 110   if (host_exists) {
 111     CHECK(false)
 112         << "RenderFrameHostChanged called more than once for routing pair:"
 113         << Format(new_host);
 114   }
 115 }
 116
 117 void WebContentsObserverSanityChecker::FrameDeleted(
 118     RenderFrameHost* render_frame_host) {
 119   // A frame can be deleted before RenderFrame in the renderer process is
 120   // created, so there is not much that can be enforced here.
 121   CHECK(!web_contents_destroyed_);
 122 }
 123
 124 void WebContentsObserverSanityChecker::DidStartNavigation(
 125     NavigationHandle* navigation_handle) {
 126   CHECK(!NavigationIsOngoing(navigation_handle));
 127   CHECK(!NavigationIsOngoingAndCommitted(navigation_handle));
 128
 129   CHECK(navigation_handle->GetNetErrorCode() == net::OK);
 130   CHECK(!navigation_handle->HasCommittedDocument());
 131   CHECK(!navigation_handle->HasCommittedErrorPage());
 132
 133   ongoing_navigations_.insert(navigation_handle);
 134 }
 135
 136 void WebContentsObserverSanityChecker::DidRedirectNavigation(
 137     NavigationHandle* navigation_handle) {
 138   CHECK(NavigationIsOngoing(navigation_handle));
 139   CHECK(!NavigationIsOngoingAndCommitted(navigation_handle));
 140
 141   CHECK(navigation_handle->GetNetErrorCode() == net::OK);
 142   CHECK(!navigation_handle->HasCommittedDocument());
 143   CHECK(!navigation_handle->HasCommittedErrorPage());
 144 }
 145
 146 void WebContentsObserverSanityChecker::ReadyToCommitNavigation(
 147     NavigationHandle* navigation_handle) {
 148   CHECK(NavigationIsOngoing(navigation_handle));
 149   CHECK(!NavigationIsOngoingAndCommitted(navigation_handle));
 150
 151   CHECK(!navigation_handle->HasCommittedDocument());
 152   CHECK(!navigation_handle->HasCommittedErrorPage());
 153 }
 154
 155 void WebContentsObserverSanityChecker::DidCommitNavigation(
 156     NavigationHandle* navigation_handle) {
 157   CHECK(NavigationIsOngoing(navigation_handle));
 158   CHECK(!NavigationIsOngoingAndCommitted(navigation_handle));
 159
 160   CHECK_NE(navigation_handle->HasCommittedDocument(),
 161            navigation_handle->HasCommittedErrorPage());
 162   CHECK_IMPLIES(navigation_handle->HasCommittedDocument(),
 163                 navigation_handle->GetNetErrorCode() == net::OK);
 164   CHECK_IMPLIES(navigation_handle->HasCommittedErrorPage(),
 165                 navigation_handle->GetNetErrorCode() != net::OK);
 166
 167   ongoing_committed_navigations_.insert(navigation_handle);
 168 }
 169
 170 void WebContentsObserverSanityChecker::DidFinishNavigation(
 171     NavigationHandle* navigation_handle) {
 172   CHECK(NavigationIsOngoing(navigation_handle));
 173
 174   CHECK_IMPLIES(NavigationIsOngoingAndCommitted(navigation_handle),
 175                 navigation_handle->HasCommittedDocument() !=
 176                     navigation_handle->HasCommittedErrorPage());
 177   CHECK_IMPLIES(navigation_handle->HasCommittedDocument(),
 178                 navigation_handle->GetNetErrorCode() == net::OK);
 179   CHECK_IMPLIES(navigation_handle->HasCommittedErrorPage(),
 180                 navigation_handle->GetNetErrorCode() != net::OK);
 181
 182   if (NavigationIsOngoingAndCommitted(navigation_handle))
 183     ongoing_committed_navigations_.erase(navigation_handle);
 184
 185   ongoing_navigations_.erase(navigation_handle);
 186 }
 187
 188 void WebContentsObserverSanityChecker::DidStartProvisionalLoadForFrame(
 189     RenderFrameHost* render_frame_host,
 190     const GURL& validated_url,
 191     bool is_error_page,
 192     bool is_iframe_srcdoc) {
 193   AssertRenderFrameExists(render_frame_host);
 194 }
 195
 196 void WebContentsObserverSanityChecker::DidCommitProvisionalLoadForFrame(
 197     RenderFrameHost* render_frame_host,
 198     const GURL& url,
 199     ui::PageTransition transition_type) {
 200   AssertRenderFrameExists(render_frame_host);
 201 }
 202
 203 void WebContentsObserverSanityChecker::DidFailProvisionalLoad(
 204     RenderFrameHost* render_frame_host,
 205     const GURL& validated_url,
 206     int error_code,
 207     const base::string16& error_description,
 208     bool was_ignored_by_handler) {
 209   AssertRenderFrameExists(render_frame_host);
 210 }
 211
 212 void WebContentsObserverSanityChecker::DidNavigateMainFrame(
 213     const LoadCommittedDetails& details,
 214     const FrameNavigateParams& params) {
 215   AssertMainFrameExists();
 216 }
 217
 218 void WebContentsObserverSanityChecker::DidNavigateAnyFrame(
 219     RenderFrameHost* render_frame_host,
 220     const LoadCommittedDetails& details,
 221     const FrameNavigateParams& params) {
 222   AssertRenderFrameExists(render_frame_host);
 223 }
 224
 225 void WebContentsObserverSanityChecker::DocumentAvailableInMainFrame() {
 226   AssertMainFrameExists();
 227 }
 228
 229 void WebContentsObserverSanityChecker::DocumentOnLoadCompletedInMainFrame() {
 230   AssertMainFrameExists();
 231 }
 232
 233 void WebContentsObserverSanityChecker::DocumentLoadedInFrame(
 234     RenderFrameHost* render_frame_host) {
 235   AssertRenderFrameExists(render_frame_host);
 236 }
 237
 238 void WebContentsObserverSanityChecker::DidFinishLoad(
 239     RenderFrameHost* render_frame_host,
 240     const GURL& validated_url) {
 241   AssertRenderFrameExists(render_frame_host);
 242 }
 243
 244 void WebContentsObserverSanityChecker::DidFailLoad(
 245     RenderFrameHost* render_frame_host,
 246     const GURL& validated_url,
 247     int error_code,
 248     const base::string16& error_description,
 249     bool was_ignored_by_handler) {
 250   AssertRenderFrameExists(render_frame_host);
 251 }
 252
 253 void WebContentsObserverSanityChecker::DidGetRedirectForResourceRequest(
 254     RenderFrameHost* render_frame_host,
 255     const ResourceRedirectDetails& details) {
 256   AssertRenderFrameExists(render_frame_host);
 257 }
 258
 259 void WebContentsObserverSanityChecker::DidOpenRequestedURL(
 260     WebContents* new_contents,
 261     RenderFrameHost* source_render_frame_host,
 262     const GURL& url,
 263     const Referrer& referrer,
 264     WindowOpenDisposition disposition,
 265     ui::PageTransition transition) {
 266   AssertRenderFrameExists(source_render_frame_host);
 267 }
 268
 269 bool WebContentsObserverSanityChecker::OnMessageReceived(
 270     const IPC::Message& message,
 271     RenderFrameHost* render_frame_host) {
 272   // TODO(nasko): FrameHostMsg_RenderProcessGone is delivered to
 273   // WebContentsObserver since RenderFrameHost allows the delegate to handle
 274   // the message first. This shouldn't happen, but for now handle it here.
 275   // https://crbug.com/450799
 276   if (message.type() == FrameHostMsg_RenderProcessGone::ID)
 277     return false;
 278
 279 #if !defined(OS_MACOSX)
 280 // TODO(avi): Disabled because of http://crbug.com/445054
 281   AssertRenderFrameExists(render_frame_host);
 282 #endif
 283   return false;
 284 }
 285
 286 void WebContentsObserverSanityChecker::WebContentsDestroyed() {
 287   CHECK(!web_contents_destroyed_);
 288   web_contents_destroyed_ = true;
 289   CHECK(ongoing_navigations_.empty());
 290   CHECK(ongoing_committed_navigations_.empty());
 291 }
 292
 293 WebContentsObserverSanityChecker::WebContentsObserverSanityChecker(
 294     WebContents* web_contents)
 295     : WebContentsObserver(web_contents), web_contents_destroyed_(false) {
 296   // Prime the pump with the initial objects.
 297   // TODO(nasko): Investigate why this is needed.
 298   RenderViewCreated(web_contents->GetRenderViewHost());
 299 }
 300
 301 WebContentsObserverSanityChecker::~WebContentsObserverSanityChecker() {
 302   CHECK(web_contents_destroyed_);
 303 }
 304
 305 void WebContentsObserverSanityChecker::AssertRenderFrameExists(
 306     RenderFrameHost* render_frame_host) {
 307   CHECK(!web_contents_destroyed_);
 308   std::pair<int, int> routing_pair =
 309       std::make_pair(render_frame_host->GetProcess()->GetID(),
 310                      render_frame_host->GetRoutingID());
 311
 312   bool render_frame_created_happened = live_routes_.count(routing_pair) != 0;
 313   bool render_frame_deleted_happened = deleted_routes_.count(routing_pair) != 0;
 314
 315   CHECK(render_frame_created_happened)
 316       << "A RenderFrameHost pointer was passed to a WebContentsObserver "
 317       << "method, but WebContentsObserver::RenderFrameCreated was never called "
 318       << "for that RenderFrameHost: " << Format(render_frame_host);
 319   CHECK(!render_frame_deleted_happened)
 320       << "A RenderFrameHost pointer was passed to a WebContentsObserver "
 321       << "method, but WebContentsObserver::RenderFrameDeleted had already been "
 322       << "called on that frame:" << Format(render_frame_host);
 323 }
 324
 325 void WebContentsObserverSanityChecker::AssertMainFrameExists() {
 326   AssertRenderFrameExists(web_contents()->GetMainFrame());
 327 }
 328
 329 std::string WebContentsObserverSanityChecker::Format(
 330     RenderFrameHost* render_frame_host) {
 331   return base::StringPrintf(
 332       "(%d, %d -> %s)", render_frame_host->GetProcess()->GetID(),
 333       render_frame_host->GetRoutingID(),
 334       render_frame_host->GetSiteInstance()->GetSiteURL().spec().c_str());
 335 }
 336
 337 bool WebContentsObserverSanityChecker::NavigationIsOngoing(
 338     NavigationHandle* navigation_handle) {
 339   auto it = ongoing_navigations_.find(navigation_handle);
 340   return it != ongoing_navigations_.end();
 341 }
 342
 343 bool WebContentsObserverSanityChecker::NavigationIsOngoingAndCommitted(
 344     NavigationHandle* navigation_handle) {
 345   auto it = ongoing_committed_navigations_.find(navigation_handle);
 346   return it != ongoing_committed_navigations_.end();
 347 }
 348
 349 }  // namespace content