PlzNavigate: Get StreamPrivate API to work.

extensions/browser/guest_view/mime_handler_view/mime_handler_stream_manager.cc

 // Copyright 2015 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 "extensions/browser/guest_view/mime_handler_view/mime_handler_stream_manager.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+#include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
 
 namespace extensions {
 namespace {
 
 class MimeHandlerStreamManagerFactory
@@ skipping 44 matching lines @@
 }  // namespace
 
 // A WebContentsObserver that observes for a particular RenderFrameHost either
 // navigating or closing (including by crashing). This is necessary to ensure
 // that streams that aren't claimed by a MimeHandlerViewGuest are not leaked, by
 // aborting the stream if any of those events occurs.
 class MimeHandlerStreamManager::EmbedderObserver
     : public content::WebContentsObserver {
  public:
   EmbedderObserver(MimeHandlerStreamManager* stream_manager,
-                   int render_process_id,
-                   int render_frame_id,
-                   const std::string& view_id);
+                   const std::string& view_id,
+                   content::WebContents* web_contents);
 
  private:
   // WebContentsObserver overrides.
-  void RenderFrameDeleted(content::RenderFrameHost* render_frame_host) override;
-  void RenderProcessGone(base::TerminationStatus status) override;
-  void DidStartProvisionalLoadForFrame(
-      content::RenderFrameHost* render_frame_host,
-      const GURL& validated_url,
-      bool is_error_page,
-      bool is_iframe_srcdoc) override;
+  void DidStartNavigation(
+      content::NavigationHandle* navigation_handle) override;
   void WebContentsDestroyed() override;
 
   void AbortStream();
 
   bool IsTrackedRenderFrameHost(content::RenderFrameHost* render_frame_host);
 
   MimeHandlerStreamManager* const stream_manager_;
-  const int render_process_id_;
-  const int render_frame_id_;
   const std::string view_id_;
 };
 
 MimeHandlerStreamManager::MimeHandlerStreamManager()
     : extension_registry_observer_(this) {
 }
 
 MimeHandlerStreamManager::~MimeHandlerStreamManager() {
 }
 
 // static
 MimeHandlerStreamManager* MimeHandlerStreamManager::Get(
     content::BrowserContext* context) {
   return MimeHandlerStreamManagerFactory::GetInstance()->Get(context);
 }
 
 void MimeHandlerStreamManager::AddStream(
     const std::string& view_id,
     std::unique_ptr<StreamContainer> stream,
-    int render_process_id,
-    int render_frame_id) {
+    content::WebContents* web_contents) {
   streams_by_extension_id_[stream->extension_id()].insert(view_id);
   auto result = streams_.insert(std::make_pair(view_id, std::move(stream)));
   DCHECK(result.second);
-  embedder_observers_[view_id] = base::MakeUnique<EmbedderObserver>(
-      this, render_process_id, render_frame_id, view_id);
+  embedder_observers_[view_id] =
+      base::MakeUnique<EmbedderObserver>(this, view_id, web_contents);
 }
 
 std::unique_ptr<StreamContainer> MimeHandlerStreamManager::ReleaseStream(
     const std::string& view_id) {
   auto stream = streams_.find(view_id);
   if (stream == streams_.end())
     return nullptr;
 
   std::unique_ptr<StreamContainer> result =
       base::WrapUnique(stream->second.release());
@@ skipping 13 matching lines @@
 
   for (const auto& view_id : streams->second) {
     streams_.erase(view_id);
     embedder_observers_.erase(view_id);
   }
   streams_by_extension_id_.erase(streams);
 }
 
 MimeHandlerStreamManager::EmbedderObserver::EmbedderObserver(
     MimeHandlerStreamManager* stream_manager,
-    int render_process_id,
-    int render_frame_id,
-    const std::string& view_id)
-    : WebContentsObserver(content::WebContents::FromRenderFrameHost(
-          content::RenderFrameHost::FromID(render_process_id,
-                                           render_frame_id))),
+    const std::string& view_id,
+    content::WebContents* web_contents)
+    : WebContentsObserver(web_contents),
       stream_manager_(stream_manager),
-      render_process_id_(render_process_id),
-      render_frame_id_(render_frame_id),
-      view_id_(view_id) {
-}
+      view_id_(view_id) {}
 
-void MimeHandlerStreamManager::EmbedderObserver::RenderFrameDeleted(

[clamy, 2016/09/15 13:15:24]

RenderFrameDeleted & RenderProcessGone would also cover additional cases beyond
the main frame navigation. Is it ok to remove them?

[ananta, 2016/09/15 21:25:03]

I think so. The only issue is the stream would remain around in some cases which
should not be a problem?.

[clamy, 2016/09/16 11:41:21]

Could that potentially lead to wasted memory?

[lazyboy, 2016/09/16 17:59:45]

+1, If the embedder page loads an iframe, and we put a pdf inside that iframe...
then navigating the iframe would lead to keeping the frame's associated streams
around, right?

[ananta, 2016/09/16 23:56:31]

I reverted portions of this file to bring back the render_frame_id and
render_process_id parameters and also pass in the frame_tree_node_id parameters.
This parameter is used for validating if the corresponding frame navigated away
in the PlzNavigate case. In the non PlzNavigate case we check using the
render_frame_id and process_id as before.

For PlzNavigate  we cleanup the stream only when we receive a navigate for the
main frame or the child frame, or when the renderer process has gone.

-    content::RenderFrameHost* render_frame_host) {
-  if (!IsTrackedRenderFrameHost(render_frame_host))
-    return;
-
-  AbortStream();
-}
-
-void MimeHandlerStreamManager::EmbedderObserver::RenderProcessGone(
-    base::TerminationStatus status) {
-  AbortStream();
-}
-void MimeHandlerStreamManager::EmbedderObserver::
-    DidStartProvisionalLoadForFrame(content::RenderFrameHost* render_frame_host,
-                                    const GURL& validated_url,
-                                    bool is_error_page,
-                                    bool is_iframe_srcdoc) {
-  if (!IsTrackedRenderFrameHost(render_frame_host))
-    return;
-
-  AbortStream();
+void MimeHandlerStreamManager::EmbedderObserver::DidStartNavigation(
+    content::NavigationHandle* navigation_handle) {
+  // If the top level frame is navigating away clean up the associated stream.
+  // Please note that the stream may be associated with a child frame.
+  if (navigation_handle->IsInMainFrame())
+    AbortStream();
 }
 
 void MimeHandlerStreamManager::EmbedderObserver::WebContentsDestroyed() {
   AbortStream();
 }
 
 void MimeHandlerStreamManager::EmbedderObserver::AbortStream() {
   Observe(nullptr);
   // This will cause the stream to be destroyed.
   stream_manager_->ReleaseStream(view_id_);
 }
 
-bool MimeHandlerStreamManager::EmbedderObserver::IsTrackedRenderFrameHost(
-    content::RenderFrameHost* render_frame_host) {
-  return render_frame_host->GetRoutingID() == render_frame_id_ &&
-         render_frame_host->GetProcess()->GetID() == render_process_id_;
-}
-
 }  // namespace extensions