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/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 670 matching lines @@
   if (base::EndsWith(url.path(), ".webm", base::CompareCase::INSENSITIVE_ASCII))
     return true;
 
   // Otherwise, WMPI can only be used if AVDA is working.
   return (!base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableAcceleratedVideoDecode) &&
           media::MediaCodecUtil::IsMediaCodecAvailable());
 }
 #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, int32_t handle_commit_id) override {
+    rfi_->ReceiveNavigationDataPipeConsumerHandle(
+      std::move(data_consumer_handle), 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 220 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_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 3660 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;
+  // // 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;
 
-  NavigateInternal(common_params, StartNavigationParams(), request_params,
-                   std::move(stream_override));
+  // NavigateInternal(common_params, StartNavigationParams(), request_params,
+  //                  std::move(stream_override));
+  navigation_response = response;
+  navigation_stream_url = stream_url;
+  navigation_common_params = common_params;
+  navigation_request_params = request_params;
+
+  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, int32_t handle_commit_id) {
+  latest_handle_ = std::move(data_consumer_handle);
+  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->stream_url = navigation_stream_url;
+    stream_override->response = navigation_response;
+
+    NavigateInternal(navigation_common_params,
+                     StartNavigationParams(),
+                     navigation_request_params,
+                     std::move(stream_override));
+                     // no_sync_needed ? mojo::ScopedDataPipeConsumerHandle() : std::move(latest_handle_));
+  } 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.
 }
 
 void RenderFrameImpl::OnFailedNavigation(
     const CommonNavigationParams& common_params,
     const RequestNavigationParams& request_params,
     bool has_stale_copy_in_cache,
     int error_code) {
   bool is_reload = IsReload(common_params.navigation_type);
   bool is_history_navigation = request_params.page_state.IsValid();
   WebURLRequest::CachePolicy cache_policy =
@@ skipping 1334 matching lines @@
   return cdm_factory_.get();
 }
 
 void RenderFrameImpl::RegisterMojoServices() {
   // Only main frame have ImageDownloader service.
   if (!frame_->parent()) {
     GetServiceRegistry()->AddService<image_downloader::ImageDownloader>(
         base::Bind(&ImageDownloaderImpl::CreateMojoService,
                    base::Unretained(this)));
   }
+
+  GetServiceRegistry()->AddService<DataPipeConsumerHandleReceiver>(
+      base::Bind(&DataPipeConsumerHandleReceiverImpl::CreateService,
+                 base::Unretained(this)));
 }
 
 template <typename Interface>
 void RenderFrameImpl::ConnectToService(
     mojo::InterfaceRequest<Interface> request) {
   GetServiceRegistry()->ConnectToRemoteService(std::move(request));
 }
 
 mojo::ServiceProviderPtr RenderFrameImpl::ConnectToApplication(
     const GURL& url) {
@@ skipping 53 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