PROTOTYPE: PlzNavigate: use a Mojo data pipe to stream navigation data to the renderer.

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 34 matching lines @@
 #include "content/child/web_url_loader_impl.h"
 #include "content/child/web_url_request_util.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/child/websocket_bridge.h"
 #include "content/child/weburlresponse_extradata_impl.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/clipboard_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/common/frame_replication_state.h"
 #include "content/common/input_messages.h"
-#include "content/common/navigation_params.h"
 #include "content/common/page_messages.h"
+#include "content/common/render_frame_setup.mojom.h"
 #include "content/common/savable_subframe.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/common/isolated_world_ids.h"
 #include "content/public/common/page_state.h"
-#include "content/public/common/resource_response.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/renderer/browser_plugin_delegate.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/context_menu_client.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame_observer.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/accessibility/renderer_accessibility.h"
@@ skipping 694 matching lines @@
                      base::CompareCase::INSENSITIVE_ASCII) &&
       !media::HasPlatformDecoderSupport()) {
     return false;
   }
 
   // Otherwise enable WMPI if indicated via experiment or command line.
   return media::IsUnifiedMediaPipelineEnabled();
 }
 #endif  // defined(OS_ANDROID)
 
+class DataPipeConsumerHandleReceiverImpl
+    : public DataPipeConsumerHandleReceiver {
+ public:
+  static void CreateService(
+      RenderFrameImpl* rfi,
+      mojo::InterfaceRequest<DataPipeConsumerHandleReceiver> request) {
+    // No leak here because of mojo::StrongBinding usage.
+    new DataPipeConsumerHandleReceiverImpl(rfi, std::move(request));
+  }
+
+  void ReceiveDataPipeConsumerHandle(
+      mojo::ScopedDataPipeConsumerHandle data_consumer_handle,
+      int browser_request_id,
+      int32_t handle_commit_id) override {
+    rfi_->ReceiveNavigationDataPipeConsumerHandle(
+        std::move(data_consumer_handle), browser_request_id, handle_commit_id);
+  }
+
+ private:
+  DataPipeConsumerHandleReceiverImpl(
+      RenderFrameImpl* rfi,
+      mojo::InterfaceRequest<DataPipeConsumerHandleReceiver> request)
+      : rfi_(rfi), binding_(this, std::move(request)) {}
+
+  RenderFrameImpl* rfi_;
+  mojo::StrongBinding<DataPipeConsumerHandleReceiver> binding_;
+};
+
 }  // namespace
 
 // static
 RenderFrameImpl* RenderFrameImpl::Create(RenderViewImpl* render_view,
                                          int32_t routing_id) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
   CreateParams params(render_view, routing_id);
 
   if (g_create_render_frame_impl)
     return g_create_render_frame_impl(params);
@@ skipping 214 matching lines @@
       geolocation_dispatcher_(NULL),
       push_messaging_dispatcher_(NULL),
       presentation_dispatcher_(NULL),
       screen_orientation_dispatcher_(NULL),
       manifest_manager_(NULL),
       accessibility_mode_(AccessibilityModeOff),
       renderer_accessibility_(NULL),
       media_player_delegate_(NULL),
       is_using_lofi_(false),
       is_pasting_(false),
+      latest_browser_request_id_(-1),
+      latest_handle_commit_id_(-1),
+      handle_render_thread_(nullptr),
+      latest_navigation_commit_id_(-1),
+      navigation_render_thread_(nullptr),
       weak_factory_(this) {
   std::pair<RoutingIDFrameMap::iterator, bool> result =
       g_routing_id_frame_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   RenderThread::Get()->AddRoute(routing_id_, this);
 
   render_view_->RegisterRenderFrame(this);
 
   // Everything below subclasses RenderFrameObserver and is automatically
@@ skipping 3578 matching lines @@
 void RenderFrameImpl::FocusedNodeChangedForAccessibility(const WebNode& node) {
   if (renderer_accessibility())
     renderer_accessibility()->AccessibilityFocusedNodeChanged(node);
 }
 
 // PlzNavigate
 void RenderFrameImpl::OnCommitNavigation(
     const ResourceResponseHead& response,
     const GURL& stream_url,
     const CommonNavigationParams& common_params,
-    const RequestNavigationParams& request_params) {
+    const RequestNavigationParams& request_params,
+    int32_t navigation_commit_id) {
   CHECK(IsBrowserSideNavigationEnabled());
-  // This will override the url requested by the WebURLLoader, as well as
-  // provide it with the response to the request.
-  scoped_ptr<StreamOverrideParameters> stream_override(
-      new StreamOverrideParameters());
-  stream_override->stream_url = stream_url;
-  stream_override->response = response;
+  navigation_response_ = response;
+  navigation_stream_url_ = stream_url;
+  navigation_common_params_ = common_params;
+  navigation_request_params_ = request_params;
 
-  NavigateInternal(common_params, StartNavigationParams(), request_params,
-                   std::move(stream_override));
+  latest_navigation_commit_id_ = navigation_commit_id;
+  navigation_render_thread_ = RenderThreadImpl::current();
+  NavigateIfIPCSynched(navigation_commit_id < 0);
 }
 
 // PlzNavigate
+void RenderFrameImpl::ReceiveNavigationDataPipeConsumerHandle(
+    mojo::ScopedDataPipeConsumerHandle data_consumer_handle,
+    int browser_request_id,
+    int32_t handle_commit_id) {
+  latest_handle_ = std::move(data_consumer_handle);
+  latest_browser_request_id_ = browser_request_id;
+  latest_handle_commit_id_ = handle_commit_id;
+  handle_render_thread_ = RenderThreadImpl::current();
+  RenderFrameImpl::NavigateIfIPCSynched(false);
+}
+
+void RenderFrameImpl::NavigateIfIPCSynched(bool no_sync_needed) {
+  if (no_sync_needed ||
+      latest_navigation_commit_id_ == latest_handle_commit_id_) {
+    LOG(ERROR) << "*** NAVIGATED with commit id: "
+               << latest_navigation_commit_id_ << " ***";
+    if (navigation_render_thread_ != nullptr &&
+        handle_render_thread_ != nullptr &&
+        navigation_render_thread_ != handle_render_thread_) {
+      LOG(ERROR) << "*** AHHHHHHHHHHHHHHH! THREADS DIFFER !!!! ***";
+    }
+    // This will override the url requested by the WebURLLoader, as well as
+    // provide it with the response to the request.
+    scoped_ptr<StreamOverrideParameters> stream_override(
+        new StreamOverrideParameters());
+    stream_override->response = navigation_response_;
+    stream_override->mojo_handle = no_sync_needed
+                                       ? mojo::ScopedDataPipeConsumerHandle()
+                                       : std::move(latest_handle_);
+    stream_override->browser_request_id = latest_browser_request_id_;
+
+    NavigateInternal(navigation_common_params_, StartNavigationParams(),
+                     navigation_request_params_, std::move(stream_override));
+  } else {
+    LOG(ERROR) << "*** Still waiting on the "
+               << (latest_navigation_commit_id_ < latest_handle_commit_id_
+                       ? "NAVIGATION"
+                       : "HANDLE")
+               << " commit id to navigate";
+    LOG(ERROR) << "***   latest_navigation_commit_id_ : "
+               << latest_navigation_commit_id_;
+    LOG(ERROR) << "***   latest_handle_commit_id_     : "
+               << latest_handle_commit_id_;
+  }
+  // TODO: throw away the extra stored data when a newer handle of the other
+  // type is received.
+}
+
+// PlzNavigate
 void RenderFrameImpl::OnFailedNavigation(
     const CommonNavigationParams& common_params,
     const RequestNavigationParams& request_params,
     bool has_stale_copy_in_cache,
     int error_code) {
   DCHECK(IsBrowserSideNavigationEnabled());
   bool is_reload = IsReload(common_params.navigation_type);
   bool is_history_navigation = request_params.page_state.IsValid();
   WebURLRequest::CachePolicy cache_policy =
       WebURLRequest::UseProtocolCachePolicy;
@@ skipping 1363 matching lines @@
 #endif
   return decoder_factory_.get();
 }
 
 void RenderFrameImpl::RegisterMojoServices() {
   // Only main frame have ImageDownloader service.
   if (!frame_->parent()) {
     GetServiceRegistry()->AddService(base::Bind(
         &ImageDownloaderImpl::CreateMojoService, base::Unretained(this)));
   }
+
+  GetServiceRegistry()->AddService<DataPipeConsumerHandleReceiver>(
+      base::Bind(&DataPipeConsumerHandleReceiverImpl::CreateService,
+                 base::Unretained(this)));
 }
 
 template <typename Interface>
 void RenderFrameImpl::GetInterface(mojo::InterfaceRequest<Interface> request) {
   GetServiceRegistry()->ConnectToRemoteService(std::move(request));
 }
 
 mojo::shell::mojom::InterfaceProviderPtr RenderFrameImpl::ConnectToApplication(
     const GURL& url) {
   if (!connector_)
@@ skipping 44 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content