base: Remove the string logging from CHECK().

content/test/web_contents_observer_sanity_checker.cc

 // Copyright 2014 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 "content/test/web_contents_observer_sanity_checker.h"
 
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/common/frame_messages.h"
@@ skipping 29 matching lines @@
 }
 
 void WebContentsObserverSanityChecker::RenderFrameCreated(
     RenderFrameHost* render_frame_host) {
   CHECK(!web_contents_destroyed_);
   GlobalRoutingID routing_pair = GetRoutingPair(render_frame_host);
   bool frame_exists = !live_routes_.insert(routing_pair).second;
   deleted_routes_.erase(routing_pair);
 
   if (frame_exists) {
-    CHECK(false) << "RenderFrameCreated called more than once for routing pair:"
-                 << Format(render_frame_host);
+    // RenderFrameCreated called more than once for routing pair.
+    CHECK(false);
   }
 
-  CHECK(render_frame_host->GetProcess()->HasConnection())
-      << "RenderFrameCreated was called for a RenderFrameHost whose render "
-         "process is not currently live, so there's no way for the RenderFrame "
-         "to have been created.";
-  CHECK(
-      static_cast<RenderFrameHostImpl*>(render_frame_host)->IsRenderFrameLive())
-      << "RenderFrameCreated called on for a RenderFrameHost that thinks it is "
-         "not alive.";
+  // RenderFrameCreated was called for a RenderFrameHost whose render process is
+  // not currently live, so there's no way for the RenderFrame to have been
+  // created.
+  CHECK(render_frame_host->GetProcess()->HasConnection());
+  // RenderFrameCreated called on for a RenderFrameHost that thinks it is not
+  // alive.
+  CHECK(static_cast<RenderFrameHostImpl*>(render_frame_host)
+            ->IsRenderFrameLive());
 
   EnsureStableParentValue(render_frame_host);
   CHECK(!HasAnyChildren(render_frame_host));
   if (render_frame_host->GetParent()) {
     // It should also be a current host.
     GlobalRoutingID parent_routing_pair =
         GetRoutingPair(render_frame_host->GetParent());
 
-    CHECK(current_hosts_.count(parent_routing_pair))
-        << "RenderFrameCreated called for a RenderFrameHost whose parent was "
-        << "not a current RenderFrameHost. Only the current frame should be "
-        << "spawning children.";
+    // RenderFrameCreated called for a RenderFrameHost whose parent was not a
+    // current RenderFrameHost. Only the current frame should be spawning
+    // children.
+    CHECK(current_hosts_.count(parent_routing_pair));
   }
 }
 
 void WebContentsObserverSanityChecker::RenderFrameDeleted(
     RenderFrameHost* render_frame_host) {
   CHECK(!web_contents_destroyed_);
   GlobalRoutingID routing_pair = GetRoutingPair(render_frame_host);
   bool was_live = !!live_routes_.erase(routing_pair);
   bool was_dead_already = !deleted_routes_.insert(routing_pair).second;
 
   if (was_dead_already) {
-    CHECK(false) << "RenderFrameDeleted called more than once for routing pair "
-                 << Format(render_frame_host);
+    // RenderFrameDeleted called more than once for routing pair
+    // |Format(render_frame_host)|
+    CHECK(false);
   } else if (!was_live) {
-    CHECK(false) << "RenderFrameDeleted called for routing pair "
-                 << Format(render_frame_host)
-                 << " for which RenderFrameCreated was never called";
+    // RenderFrameDeleted called for routing pair |Format(render_frame_host)|
+    // for which RenderFrameCreated was never called
+    CHECK(false);
   }
 
   EnsureStableParentValue(render_frame_host);
   CHECK(!HasAnyChildren(render_frame_host));
   if (render_frame_host->GetParent())
     AssertRenderFrameExists(render_frame_host->GetParent());
 
   // All players should have been paused by this point.
   for (const auto& id : active_media_players_)
     CHECK_NE(id.first, render_frame_host);
 }
 
 void WebContentsObserverSanityChecker::RenderFrameForInterstitialPageCreated(
     RenderFrameHost* render_frame_host) {
   // TODO(nick): Record this.
 }
 
 void WebContentsObserverSanityChecker::RenderFrameHostChanged(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   CHECK(new_host);
   CHECK_NE(new_host, old_host);
 
   if (old_host) {
     EnsureStableParentValue(old_host);
     CHECK_EQ(old_host->GetParent(), new_host->GetParent());
     GlobalRoutingID routing_pair = GetRoutingPair(old_host);
     bool old_did_exist = !!current_hosts_.erase(routing_pair);
     if (!old_did_exist) {
-      CHECK(false)
-          << "RenderFrameHostChanged called with old host that did not exist:"
-          << Format(old_host);
+      // RenderFrameHostChanged called with old host that did not exist.
+      CHECK(false);
     }
-    CHECK(!HasAnyChildren(old_host))
-        << "All children should be detached before a parent is detached.";
+    // All children should be detached before a parent is detached.
+    CHECK(!HasAnyChildren(old_host));
   }
 
   EnsureStableParentValue(new_host);
   if (new_host->GetParent()) {
     AssertRenderFrameExists(new_host->GetParent());
-    CHECK(current_hosts_.count(GetRoutingPair(new_host->GetParent())))
-        << "Parent of frame being committed must be current.";
+    // Parent of frame being committed must be current.
+    CHECK(current_hosts_.count(GetRoutingPair(new_host->GetParent())));
   }
 
   GlobalRoutingID routing_pair = GetRoutingPair(new_host);
   bool host_exists = !current_hosts_.insert(routing_pair).second;
   if (host_exists) {
-    CHECK(false)
-        << "RenderFrameHostChanged called more than once for routing pair:"
-        << Format(new_host);
+    // RenderFrameHostChanged called more than once for routing pair.
+    CHECK(false);
   }
-  CHECK(!HasAnyChildren(new_host))
-      << "A frame should not have children before it is committed.";
+  // A frame should not have children before it is committed.
+  CHECK(!HasAnyChildren(new_host));
 }
 
 void WebContentsObserverSanityChecker::FrameDeleted(
     RenderFrameHost* render_frame_host) {
   // A frame can be deleted before RenderFrame in the renderer process is
   // created, so there is not much that can be enforced here.
   CHECK(!web_contents_destroyed_);
 
   EnsureStableParentValue(render_frame_host);
 
-  CHECK(!HasAnyChildren(render_frame_host))
-      << "All children should be deleted before a frame is detached.";
+  // All children should be deleted before a frame is detached.
+  CHECK(!HasAnyChildren(render_frame_host));
 
   GlobalRoutingID routing_pair = GetRoutingPair(render_frame_host);
-  CHECK(current_hosts_.erase(routing_pair))
-      << "FrameDeleted called with a non-current RenderFrameHost.";
+  // FrameDeleted called with a non-current RenderFrameHost.
+  CHECK(current_hosts_.erase(routing_pair));
 
   if (render_frame_host->GetParent())
     AssertRenderFrameExists(render_frame_host->GetParent());
 }
 
 void WebContentsObserverSanityChecker::DidStartNavigation(
     NavigationHandle* navigation_handle) {
   CHECK(!NavigationIsOngoing(navigation_handle));
 
   CHECK(navigation_handle->GetNetErrorCode() == net::OK);
@@ skipping 178 matching lines @@
 }
 
 void WebContentsObserverSanityChecker::AssertRenderFrameExists(
     RenderFrameHost* render_frame_host) {
   CHECK(!web_contents_destroyed_);
   GlobalRoutingID routing_pair = GetRoutingPair(render_frame_host);
 
   bool render_frame_created_happened = live_routes_.count(routing_pair) != 0;
   bool render_frame_deleted_happened = deleted_routes_.count(routing_pair) != 0;
 
-  CHECK(render_frame_created_happened)
-      << "A RenderFrameHost pointer was passed to a WebContentsObserver "
-      << "method, but WebContentsObserver::RenderFrameCreated was never called "
-      << "for that RenderFrameHost: " << Format(render_frame_host);
-  CHECK(!render_frame_deleted_happened)
-      << "A RenderFrameHost pointer was passed to a WebContentsObserver "
-      << "method, but WebContentsObserver::RenderFrameDeleted had already been "
-      << "called on that frame:" << Format(render_frame_host);
+  // A RenderFrameHost pointer was passed to a WebContentsObserver method, but
+  // WebContentsObserver::RenderFrameCreated was never called for that
+  // RenderFrameHost.
+  CHECK(render_frame_created_happened);
+  // A RenderFrameHost pointer was passed to a WebContentsObserver method, but
+  // WebContentsObserver::RenderFrameDeleted had already been called on that
+  // frame.
+  CHECK(!render_frame_deleted_happened);
 }
 
 void WebContentsObserverSanityChecker::AssertMainFrameExists() {
   AssertRenderFrameExists(web_contents()->GetMainFrame());
 }
 
 std::string WebContentsObserverSanityChecker::Format(
     RenderFrameHost* render_frame_host) {
   return base::StringPrintf(
       "(%d, %d -> %s)", render_frame_host->GetProcess()->GetID(),
@@ skipping 11 matching lines @@
     RenderFrameHost* render_frame_host) {
   GlobalRoutingID routing_pair = GetRoutingPair(render_frame_host);
   GlobalRoutingID parent_routing_pair =
       GetRoutingPair(render_frame_host->GetParent());
 
   auto it = parent_ids_.find(routing_pair);
   if (it == parent_ids_.end()) {
     parent_ids_.insert(std::make_pair(routing_pair, parent_routing_pair));
   } else {
     GlobalRoutingID former_parent_routing_pair = it->second;
-    CHECK(former_parent_routing_pair == parent_routing_pair)
-        << "RFH's parent value changed over time! That is really not good!";
+    // RFH's parent value changed over time! That is really not good!
+    CHECK(former_parent_routing_pair == parent_routing_pair);
   }
 }
 
 bool WebContentsObserverSanityChecker::HasAnyChildren(RenderFrameHost* parent) {
   GlobalRoutingID parent_routing_pair = GetRoutingPair(parent);
   for (auto& entry : parent_ids_) {
     if (entry.second == parent_routing_pair) {
       if (live_routes_.count(entry.first))
         return true;
       if (current_hosts_.count(entry.first))
         return true;
     }
   }
   return false;
 }
 
 }  // namespace content