Remove old diagnostic crash reports.

content/renderer/render_frame_impl.cc

 // Copyright 2013 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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 1701 matching lines @@
   // unload on subframes as well.
   if (is_main_frame_)
     frame_->dispatchUnloadEvent();
 
   // Swap out and stop sending any IPC messages that are not ACKs.
   if (is_main_frame_)
     render_view_->SetSwappedOut(true);
 
   RenderViewImpl* render_view = render_view_;
   bool is_main_frame = is_main_frame_;
-  int routing_id = GetRoutingID();
 
   // Now that all of the cleanup is complete and the browser side is notified,
   // start using the RenderFrameProxy.
   //
   // The swap call deletes this RenderFrame via frameDetached.  Do not access
   // any members after this call.
   //
   // TODO(creis): WebFrame::swap() can return false.  Most of those cases
   // should be due to the frame being detached during unload (in which case
   // the necessary cleanup has happened anyway), but it might be possible for
   // it to return false without detaching.  Catch any cases that the
   // RenderView's main_render_frame_ isn't cleared below (whether swap returns
-  // false or not), to track down https://crbug.com/575245.
+  // false or not).
   bool success = frame_->swap(proxy->web_frame());
 
   // For main frames, the swap should have cleared the RenderView's pointer to
   // this frame.
-  if (is_main_frame) {
-    base::debug::SetCrashKeyValue("swapout_frame_id",
-                                  base::IntToString(routing_id));
-    base::debug::SetCrashKeyValue("swapout_proxy_id",
-                                  base::IntToString(proxy->routing_id()));
-    base::debug::SetCrashKeyValue(
-        "swapout_view_id", base::IntToString(render_view->GetRoutingID()));
+  if (is_main_frame)
     CHECK(!render_view->main_render_frame_);

[Charlie Reis, 2016/12/13 00:07:57]

I left this in place, since it seems like a useful safeguard for the future (and
I couldn't find cases of it getting hit).

[alexmos, 2016/12/13 20:28:55]

Acknowledged.

-  }
 
   if (!success) {
     // The swap can fail when the frame is detached during swap (this can
     // happen while running the unload handlers). When that happens, delete
     // the proxy.
     proxy->frameDetached(blink::WebRemoteFrameClient::DetachType::Swap);
     return;
   }
 
   if (is_loading)
     proxy->OnDidStartLoading();
 
   // Initialize the WebRemoteFrame with the replication state passed by the
   // process that is now rendering the frame.
   proxy->SetReplicatedState(replicated_frame_state);
 
   // Safe to exit if no one else is using the process.
   // TODO(nasko): Remove the dependency on RenderViewImpl here and ref count
   // the process based on the lifetime of this RenderFrameImpl object.
   if (is_main_frame)
     render_view->WasSwappedOut();
 
   // Notify the browser that this frame was swapped. Use the RenderThread
   // directly because |this| is deleted.
-  RenderThread::Get()->Send(new FrameHostMsg_SwapOut_ACK(routing_id));
+  RenderThread::Get()->Send(new FrameHostMsg_SwapOut_ACK(GetRoutingID()));
 }
 
 void RenderFrameImpl::OnDeleteFrame() {
   // TODO(nasko): If this message is received right after a commit has
   // swapped a RenderFrameProxy with this RenderFrame, the proxy needs to be
   // recreated in addition to the RenderFrame being deleted.
   // See https://crbug.com/569683 for details.
   in_browser_initiated_detach_ = true;
 
   // This will result in a call to RendeFrameImpl::frameDetached, which
@@ skipping 1765 matching lines @@
 
     // The proxy might have been detached while the provisional LocalFrame was
     // being navigated.  In that case, don't swap the frame back in the tree
     // and return early (to avoid sending confusing IPCs to the browser
     // process).  See https://crbug.com/526304 and https://crbug.com/568676.
     // TODO(nasko, alexmos): Eventually, the browser process will send an IPC
     // to clean this frame up after https://crbug.com/548275 is fixed.
     if (!proxy)
       return;
 
-    int proxy_routing_id = proxy_routing_id_;
     if (!proxy->web_frame()->swap(frame_))
       return;
     proxy_routing_id_ = MSG_ROUTING_NONE;
     in_frame_tree_ = true;
 
     // If this is the main frame going from a remote frame to a local frame,
     // it needs to set RenderViewImpl's pointer for the main frame to itself
     // and ensure RenderWidget is no longer in swapped out mode.
     if (is_main_frame_) {
-      // Debug cases of https://crbug.com/575245.
-      base::debug::SetCrashKeyValue("commit_frame_id",
-                                    base::IntToString(GetRoutingID()));
-      base::debug::SetCrashKeyValue("commit_proxy_id",
-                                    base::IntToString(proxy_routing_id));
-      base::debug::SetCrashKeyValue(
-          "commit_view_id", base::IntToString(render_view_->GetRoutingID()));
-      if (render_view_->main_render_frame_) {
-        base::debug::SetCrashKeyValue(
-            "commit_main_render_frame_id",
-            base::IntToString(
-                render_view_->main_render_frame_->GetRoutingID()));
-      }
       CHECK(!render_view_->main_render_frame_);
       render_view_->main_render_frame_ = this;
       if (render_view_->is_swapped_out())
         render_view_->SetSwappedOut(false);
     }
   }
 
   // For new page navigations, the browser process needs to be notified of the
   // first paint of that page, so it can cancel the timer that waits for it.
   if (is_main_frame_ && !navigation_state->WasWithinSamePage()) {
@@ skipping 3089 matching lines @@
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
   // the event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |pepper_last_mouse_event_target_|.
   pepper_last_mouse_event_target_ = nullptr;
 #endif
 }
 
 }  // namespace content