[DO NOT COMMIT] Test implementation of converting same URL navigation into a reload

content/browser/frame_host/render_frame_host_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/browser/frame_host/render_frame_host_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 247 matching lines @@
       accessibility_reset_token_(0),
       accessibility_reset_count_(0),
       browser_plugin_embedder_ax_tree_id_(AXTreeIDRegistry::kNoAXTreeID),
       no_create_browser_accessibility_manager_for_testing_(false),
       web_ui_type_(WebUI::kNoWebUI),
       pending_web_ui_type_(WebUI::kNoWebUI),
       should_reuse_web_ui_(false),
       last_navigation_lofi_state_(LOFI_UNSPECIFIED),
       frame_host_binding_(this),
       weak_ptr_factory_(this) {
+  LOG(ERROR) << "RFH[" << this << "]::RFH: "
+    << " routing_id:" << routing_id
+    << " instance:" << site_instance->GetId() << ":" << site_instance->GetSiteURL();
   frame_tree_->AddRenderViewHostRef(render_view_host_);
   GetProcess()->AddRoute(routing_id_, this);
   g_routing_id_frame_map.Get().insert(std::make_pair(
       RenderFrameHostID(GetProcess()->GetID(), routing_id_),
       this));
   site_instance_->AddObserver(this);
   GetSiteInstance()->IncrementActiveFrameCount();
 
   if (frame_tree_node_->parent()) {
     // Keep track of the parent RenderFrameHost, which shouldn't change even if
@@ skipping 70 matching lines @@
 
   if (render_widget_host_ &&
       render_widget_host_->owned_by_render_frame_host()) {
     // Shutdown causes the RenderWidgetHost to delete itself.
     render_widget_host_->ShutdownAndDestroyWidget(true);
   }
 
   // Notify the FrameTree that this RFH is going away, allowing it to shut down
   // the corresponding RenderViewHost if it is no longer needed.
   frame_tree_->ReleaseRenderViewHostRef(render_view_host_);
+
+  LOG(ERROR) << "RFH[" << this << "]::~RFH";
 }
 
 int RenderFrameHostImpl::GetRoutingID() {
   return routing_id_;
 }
 
 AXTreeIDRegistry::AXTreeID RenderFrameHostImpl::GetAXTreeID() {
   return AXTreeIDRegistry::GetInstance()->GetOrCreateAXTreeID(
       GetProcess()->GetID(), routing_id_);
 }
@@ skipping 627 matching lines @@
                                base::TimeDelta::FromMinutes(10), 100);
   }
   // This message is only sent for top-level frames. TODO(avi): when frame tree
   // mirroring works correctly, add a check here to enforce it.
   delegate_->DocumentOnLoadCompleted(this);
 }
 
 void RenderFrameHostImpl::OnDidStartProvisionalLoad(
     const GURL& url,
     const base::TimeTicks& navigation_start) {
+  LOG(ERROR) << "RFH[" << this << "]::DidStartProvisionalLoad: "
+    << " url:" << url.spec().substr(0, 250);
   frame_tree_node_->navigator()->DidStartProvisionalLoad(this, url,
                                                          navigation_start);
 }
 
 void RenderFrameHostImpl::OnDidFailProvisionalLoadWithError(
     const FrameHostMsg_DidFailProvisionalLoadWithError_Params& params) {
+  LOG(ERROR) << "RFH[" << this << "]::DidFailProvisionalLoadWithError: "
+    << " error:" << params.error_code;
+
   // TODO(clamy): Kill the renderer with RFH_FAIL_PROVISIONAL_LOAD_NO_HANDLE and
   // return early if navigation_handle_ is null, once we prevent that case from
   // happening in practice.
 
   // Update the error code in the NavigationHandle of the navigation.
   if (navigation_handle_) {
     navigation_handle_->set_net_error_code(
         static_cast<net::Error>(params.error_code));
   }
 
   frame_tree_node_->navigator()->DidFailProvisionalLoadWithError(this, params);
 }
 
 void RenderFrameHostImpl::OnDidFailLoadWithError(
     const GURL& url,
     int error_code,
     const base::string16& error_description,
     bool was_ignored_by_handler) {
   GURL validated_url(url);
+  LOG(ERROR) << "RFH[" << this << "]::DidFailLoadWithError: "
+    << " url:" << url.spec().substr(0, 250)
+    << " error:" << error_code;
+
   GetProcess()->FilterURL(false, &validated_url);
 
   frame_tree_node_->navigator()->DidFailLoadWithError(
       this, validated_url, error_code, error_description,
       was_ignored_by_handler);
 }
 
 // Called when the renderer navigates.  For every frame loaded, we'll get this
 // notification containing parameters identifying the navigation.
 //
 // Subframes are identified by the page transition type.  For subframes loaded
 // as part of a wider page load, the page_id will be the same as for the top
 // level frame.  If the user explicitly requests a subframe navigation, we will
 // get a new page_id because we need to create a new navigation entry for that
 // action.
 void RenderFrameHostImpl::OnDidCommitProvisionalLoad(const IPC::Message& msg) {
   ScopedCommitStateResetter commit_state_resetter(this);
   RenderProcessHost* process = GetProcess();
 
   // Read the parameters out of the IPC message directly to avoid making another
   // copy when we filter the URLs.
   base::PickleIterator iter(msg);
   FrameHostMsg_DidCommitProvisionalLoad_Params validated_params;
   if (!IPC::ParamTraits<FrameHostMsg_DidCommitProvisionalLoad_Params>::
       Read(&msg, &iter, &validated_params)) {
     bad_message::ReceivedBadMessage(
         process, bad_message::RFH_COMMIT_DESERIALIZATION_FAILED);
+    LOG(ERROR) << "RFH[" << this << "]::DidCommitProvisionalLoad: "
+      << " failed to read IPC, killed renderer";
     return;
   }
   TRACE_EVENT1("navigation", "RenderFrameHostImpl::OnDidCommitProvisionalLoad",
                "url", validated_params.url.possibly_invalid_spec());
 
+  LOG(ERROR) << "RFH[" << this << "]::DidCommitProvisionalLoad: "
+    << " url:" << validated_params.url.spec().substr(0, 250);
+
   // Sanity-check the page transition for frame type.
   DCHECK_EQ(ui::PageTransitionIsMainFrame(validated_params.transition),
             !GetParent());
 
   // If we're waiting for a cross-site beforeunload ack from this renderer and
   // we receive a Navigate message from the main frame, then the renderer was
   // navigating already and sent it before hearing the FrameMsg_Stop message.
   // Treat this as an implicit beforeunload ack to allow the pending navigation
   // to continue.
   if (is_waiting_for_beforeunload_ack_ &&
@@ skipping 218 matching lines @@
 }
 
 void RenderFrameHostImpl::SwapOut(
     RenderFrameProxyHost* proxy,
     bool is_loading) {
   // The end of this event is in OnSwapOutACK when the RenderFrame has completed
   // the operation and sends back an IPC message.
   // The trace event may not end properly if the ACK times out.  We expect this
   // to be fixed when RenderViewHostImpl::OnSwapOut moves to RenderFrameHost.
   TRACE_EVENT_ASYNC_BEGIN0("navigation", "RenderFrameHostImpl::SwapOut", this);
+  LOG(ERROR) << "RFH[" << this << "]::SwapOut";
 
   // If this RenderFrameHost is already pending deletion, it must have already
   // gone through this, therefore just return.
   if (!is_active()) {
     NOTREACHED() << "RFH should be in default state when calling SwapOut.";
     return;
   }
 
   if (swapout_event_monitor_timeout_) {
     swapout_event_monitor_timeout_->Start(base::TimeDelta::FromMilliseconds(
@@ skipping 119 matching lines @@
   if (!proceed)
     render_view_host_->GetDelegate()->DidCancelLoading();
 }
 
 bool RenderFrameHostImpl::IsWaitingForUnloadACK() const {
   return render_view_host_->is_waiting_for_close_ack_ ||
          is_waiting_for_swapout_ack_;
 }
 
 void RenderFrameHostImpl::OnSwapOutACK() {
+  LOG(ERROR) << "RFH[" << this << "]::SwapOutACK";
   OnSwappedOut();
 }
 
 void RenderFrameHostImpl::OnRenderProcessGone(int status, int exit_code) {
   if (frame_tree_node_->IsMainFrame()) {
     // Keep the termination status so we can get at it later when we
     // need to know why it died.
     render_view_host_->render_view_termination_status_ =
         static_cast<base::TerminationStatus>(status);
   }
@@ skipping 771 matching lines @@
   return CanCommitURL(origin_url);
 }
 
 void RenderFrameHostImpl::Navigate(
     const CommonNavigationParams& common_params,
     const StartNavigationParams& start_params,
     const RequestNavigationParams& request_params) {
   TRACE_EVENT0("navigation", "RenderFrameHostImpl::Navigate");
   DCHECK(!IsBrowserSideNavigationEnabled());
 
+  LOG(ERROR) << "RFH[" << this << "]::Navigate: "
+    << " url:" << common_params.url.spec().substr(0, 250);
+
   UpdatePermissionsForNavigation(common_params, request_params);
 
   // Only send the message if we aren't suspended at the start of a cross-site
   // request.
   if (navigations_suspended_) {
     // This may replace an existing set of params, if this is a pending RFH that
     // is navigated twice consecutively.
     suspended_nav_params_.reset(
         new NavigationParams(common_params, start_params, request_params));
   } else {
@@ skipping 29 matching lines @@
     CommitNavigation(nullptr, nullptr, common_params, RequestNavigationParams(),
                      false);
   } else {
     Navigate(common_params, StartNavigationParams(), RequestNavigationParams());
   }
 }
 
 void RenderFrameHostImpl::OpenURL(const FrameHostMsg_OpenURL_Params& params,
                                   SiteInstance* source_site_instance) {
   GURL validated_url(params.url);
+
+  LOG(ERROR) << "RFH[" << this << "]::OpenURL: "
+    << " url:" << validated_url.spec().substr(0, 250);
   GetProcess()->FilterURL(false, &validated_url);
 
   TRACE_EVENT1("navigation", "RenderFrameHostImpl::OpenURL", "url",
                validated_url.possibly_invalid_spec());
   frame_tree_node_->navigator()->RequestOpenURL(
       this, validated_url, params.uses_post, params.resource_request_body,
       source_site_instance, params.referrer, params.disposition,
       params.should_replace_current_entry, params.user_gesture);
 }
 
@@ skipping 126 matching lines @@
   }
 }
 
 // PlzNavigate
 void RenderFrameHostImpl::CommitNavigation(
     ResourceResponse* response,
     std::unique_ptr<StreamHandle> body,
     const CommonNavigationParams& common_params,
     const RequestNavigationParams& request_params,
     bool is_view_source) {
+  LOG(ERROR) << "RFH[" << this << "]::CommitNavigation: "
+    << " url:" << common_params.url.spec().substr(0, 250);
+
   DCHECK((response && body.get()) ||
           !ShouldMakeNetworkRequestForURL(common_params.url));
   UpdatePermissionsForNavigation(common_params, request_params);
 
   // Get back to a clean state, in case we start a new navigation without
   // completing an unload handler.
   ResetWaitingState();
 
   // The renderer can exit view source mode when any error or cancellation
   // happen. When reusing the same renderer, overwrite to recover the mode.
@@ skipping 25 matching lines @@
     pending_commit_ = true;
     is_loading_ = true;
   }
 }
 
 void RenderFrameHostImpl::FailedNavigation(
     const CommonNavigationParams& common_params,
     const RequestNavigationParams& request_params,
     bool has_stale_copy_in_cache,
     int error_code) {
+  LOG(ERROR) << "RFH[" << this << "]::FailedNavigation: "
+    << " url:" << common_params.url.spec().substr(0, 250);
   // Get back to a clean state, in case a new navigation started without
   // completing an unload handler.
   ResetWaitingState();
 
   Send(new FrameMsg_FailedNavigation(routing_id_, common_params, request_params,
                                      has_stale_copy_in_cache, error_code));
 
   // An error page is expected to commit, hence why is_loading_ is set to true.
   is_loading_ = true;
   frame_tree_node_->ResetNavigationRequest(true);
@@ skipping 575 matching lines @@
   web_bluetooth_service_->SetClientConnectionErrorHandler(base::Bind(
       &RenderFrameHostImpl::DeleteWebBluetoothService, base::Unretained(this)));
   return web_bluetooth_service_.get();
 }
 
 void RenderFrameHostImpl::DeleteWebBluetoothService() {
   web_bluetooth_service_.reset();
 }
 
 }  // namespace content