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

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 1062 matching lines @@
       is_pasting_(false),
       suppress_further_dialogs_(false),
       blame_context_(nullptr),
 #if defined(ENABLE_PLUGINS)
       focused_pepper_plugin_(nullptr),
       pepper_last_mouse_event_target_(nullptr),
 #endif
       frame_binding_(this),
       has_accessed_initial_document_(false),
       weak_factory_(this) {
+  LOG(ERROR) << "RF[" << this << "]::RF: "
+    << " routing_id:" << routing_id_;
+
   // We don't have a shell::Connection at this point, so use nullptr.
   // TODO(beng): We should fix this, so we can apply policy about which
   //             interfaces get exposed.
   interface_registry_.reset(new shell::InterfaceRegistry);
   shell::mojom::InterfaceProviderPtr remote_interfaces;
   pending_remote_interface_provider_request_ = GetProxy(&remote_interfaces);
   remote_interfaces_.reset(new shell::InterfaceProvider);
   remote_interfaces_->Bind(std::move(remote_interfaces));
   blink_interface_provider_.reset(new BlinkInterfaceProviderImpl(
       remote_interfaces_->GetWeakPtr()));
@@ skipping 51 matching lines @@
     // Ensure the RenderView doesn't point to this object, once it is destroyed.
     // TODO(nasko): Add a check that the |main_render_frame_| of |render_view_|
     // is |this|, once the object is no longer leaked.
     // See https://crbug.com/464764.
     render_view_->main_render_frame_ = nullptr;
   }
 
   render_view_->UnregisterRenderFrame(this);
   g_routing_id_frame_map.Get().erase(routing_id_);
   RenderThread::Get()->RemoveRoute(routing_id_);
+  LOG(ERROR) << "RF[" << this << "]::~RF";
 }
 
 void RenderFrameImpl::BindToWebFrame(blink::WebLocalFrame* web_frame) {
   DCHECK(!frame_);
 
   std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
       std::make_pair(web_frame, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   frame_ = web_frame;
@@ skipping 540 matching lines @@
   // 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));
 }
 
 void RenderFrameImpl::OnDeleteFrame() {
+  LOG(ERROR) << "RF[" << this << "]::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
   // deletes the object. Do not access |this| after detach.
   frame_->detach();
 }
@@ skipping 492 matching lines @@
       surroundingText.textContent(),
       surroundingText.startOffsetInTextContent(),
       surroundingText.endOffsetInTextContent()));
 }
 
 bool RenderFrameImpl::RunJavaScriptMessage(JavaScriptMessageType type,
                                            const base::string16& message,
                                            const base::string16& default_value,
                                            const GURL& frame_url,
                                            base::string16* result) {
+  LOG(ERROR) << "RF[" << this << "]::RunJavaScriptMessage: "
+    << " suppress:" << suppress_further_dialogs_;
+
   // Don't allow further dialogs if we are waiting to swap out, since the
   // ScopedPageLoadDeferrer in our stack prevents it.
   if (suppress_further_dialogs_)
     return false;
 
   bool success = false;
   base::string16 result_temp;
   if (!result)
     result = &result_temp;
 
@@ skipping 581 matching lines @@
   DCHECK(!opener || opener->isWebLocalFrame());
 
   int opener_routing_id = opener ?
       RenderFrameImpl::FromWebFrame(opener->toWebLocalFrame())->GetRoutingID() :
       MSG_ROUTING_NONE;
   Send(new FrameHostMsg_DidChangeOpener(routing_id_, opener_routing_id));
 }
 
 void RenderFrameImpl::frameDetached(blink::WebLocalFrame* frame,
                                     DetachType type) {
+  LOG(ERROR) << "RF[" << this << "]::frameDetached: "
+    << " type:" << static_cast<int>(type);
+
   // NOTE: This function is called on the frame that is being detached and not
   // the parent frame.  This is different from createChildFrame() which is
   // called on the parent frame.
   DCHECK_EQ(frame_, frame);
 
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_)
     GetRenderWidget()->set_focused_pepper_plugin(nullptr);
 #endif
 
@@ skipping 357 matching lines @@
   // In fast/loader/stop-provisional-loads.html, we abort the load before this
   // callback is invoked.
   if (!ds)
     return;
 
   TRACE_EVENT2("navigation,benchmark,rail",
                "RenderFrameImpl::didStartProvisionalLoad", "id", routing_id_,
                "url", ds->request().url().string().utf8());
   DocumentState* document_state = DocumentState::FromDataSource(ds);
 
+  LOG(ERROR) << "RF[" << this << "]::didStartProvisionalLoad: "
+      << " url:" << ds->request().url().string().utf8().substr(0, 250);
+
   // Update the request time if WebKit has better knowledge of it.
   if (document_state->request_time().is_null() &&
           triggering_event_time != 0.0) {
     document_state->set_request_time(Time::FromDoubleT(triggering_event_time));
   }
 
   // Start time is only set after request time.
   document_state->set_start_load_time(Time::Now());
 
   NavigationStateImpl* navigation_state = static_cast<NavigationStateImpl*>(
@@ skipping 19 matching lines @@
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, DidStartProvisionalLoad());
 
   Send(new FrameHostMsg_DidStartProvisionalLoad(
       routing_id_, ds->request().url(), navigation_start));
 }
 
 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
     blink::WebLocalFrame* frame) {
   DCHECK_EQ(frame_, frame);
 
+  LOG(ERROR) << "RF[" << this << "]::didReceiveServerRedirectForProvisionalLoad:";
+
   // We don't use HistoryController in OOPIF enabled modes.
   if (SiteIsolationPolicy::UseSubframeNavigationEntries())
     return;
 
   render_view_->history_controller()->RemoveChildrenForRedirect(this);
 }
 
 void RenderFrameImpl::didFailProvisionalLoad(
     blink::WebLocalFrame* frame,
     const blink::WebURLError& error,
     blink::WebHistoryCommitType commit_type) {
   TRACE_EVENT1("navigation,benchmark,rail",
                "RenderFrameImpl::didFailProvisionalLoad", "id", routing_id_);
   DCHECK_EQ(frame_, frame);
   WebDataSource* ds = frame->provisionalDataSource();
   DCHECK(ds);
 
+  LOG(ERROR) << "RF[" << this << "]::didFailProvisionalLoad: "
+    << " url:" << ds->request().url().string().utf8().substr(0, 250);
+
   const WebURLRequest& failed_request = ds->request();
 
   // Notify the browser that we failed a provisional load with an error.
   //
   // Note: It is important this notification occur before DidStopLoading so the
   //       SSL manager can react to the provisional load failure before being
   //       notified the load stopped.
   //
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
                     DidFailProvisionalLoad(frame, error));
@@ skipping 51 matching lines @@
   // change at commit time.
   if (is_main_frame_ && !navigation_state->WasWithinSamePage()) {
     is_using_lofi_ = extra_data && extra_data->is_using_lofi();
     if (extra_data) {
       effective_connection_type_ =
           EffectiveConnectionTypeToWebEffectiveConnectionType(
               extra_data->effective_connection_type());
     }
   }
 
+  LOG(ERROR) << "RF[" << this << "]::didCommitProvisionalLoad: "
+    << " url:" << GetLoadingUrl().spec().substr(0, 250);
+
   if (proxy_routing_id_ != MSG_ROUTING_NONE) {
     RenderFrameProxy* proxy =
         RenderFrameProxy::FromRoutingID(proxy_routing_id_);
 
     // 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.
@@ skipping 245 matching lines @@
 }
 
 void RenderFrameImpl::didFinishDocumentLoad(blink::WebLocalFrame* frame) {
   TRACE_EVENT1("navigation,benchmark,rail",
                "RenderFrameImpl::didFinishDocumentLoad", "id", routing_id_);
   DCHECK_EQ(frame_, frame);
   WebDataSource* ds = frame->dataSource();
   DocumentState* document_state = DocumentState::FromDataSource(ds);
   document_state->set_finish_document_load_time(Time::Now());
 
+  LOG(ERROR) << "RF[" << this << "]::didFinishDocumentLoad: "
+    << " url:" << frame->document().url().string().utf8().substr(0, 250);
+
   Send(new FrameHostMsg_DidFinishDocumentLoad(routing_id_));
 
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
                     DidFinishDocumentLoad(frame));
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, DidFinishDocumentLoad());
 
   // Check whether we have new encoding name.
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
@@ skipping 2745 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