PlzNavigate: Get StreamPrivate API to work.

chrome/browser/extensions/api/streams_private/streams_private_api.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/streams_private/streams_private_api.h"
 
 #include <limits.h>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/common/extensions/api/streams_private.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/browser/stream_info.h"
+#include "content/public/browser/web_contents.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function_registry.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/guest_view/mime_handler_view/mime_handler_stream_manager.h"
 #include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
 #include "extensions/common/manifest_handlers/mime_types_handler.h"
 #include "net/http/http_response_headers.h"
 
 namespace extensions {
 namespace {
@@ skipping 32 matching lines @@
       extension_registry_observer_(this),
       weak_ptr_factory_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 }
 
 StreamsPrivateAPI::~StreamsPrivateAPI() {
 }
 
 void StreamsPrivateAPI::ExecuteMimeTypeHandler(
     const std::string& extension_id,
-    content::WebContents* web_contents,

[nasko, 2016/09/21 21:32:18]

Why can't we pass this through to the MimeHandlerStreamManager?

[ananta, 2016/09/21 21:59:12]

Please refer to jam's comment a couple patchsets before. His point was it seems
redundant to pass WebContents, FTNID, RFID, RPID to a function. And it could
lead to bad practices  like passing an unrelated WebContents pointer to such
functions. 

His suggestion was to add a static getter to WebContents which returns it based
on a FTNID

[nasko, 2016/09/21 22:08:55]

I completely agree with avoiding the redundancy. What I'm trying to say is that
if this code (aka MimeHandlerStreamManager) is only using GuestView, there is no
reason to pass in an RFH, since passing the WebContents and using its main frame
is equivalent. It will also be very clear that the unit of operation of this
code is WebContents rather than a frame granularity.

     std::unique_ptr<content::StreamInfo> stream,
     const std::string& view_id,
     int64_t expected_content_size,
     bool embedded,
+    int frame_tree_node_id,
     int render_process_id,
     int render_frame_id) {
   const Extension* extension = ExtensionRegistry::Get(browser_context_)
                                    ->enabled_extensions()
                                    .GetByID(extension_id);
   if (!extension)
     return;
 
+  content::WebContents* web_contents = nullptr;
+  if (frame_tree_node_id != -1) {
+    web_contents =
+        content::WebContents::FromFrameTreeNodeId(frame_tree_node_id);
+  } else {
+    web_contents = content::WebContents::FromRenderFrameHost(
+        content::RenderFrameHost::FromID(render_process_id, render_frame_id));
+  }
+  if (!web_contents)
+    return;
+
   MimeTypesHandler* handler = MimeTypesHandler::GetHandler(extension);
   // If the mime handler uses MimeHandlerViewGuest, the MimeHandlerViewGuest
   // will take ownership of the stream. Otherwise, store the stream handle in
   // |streams_| and fire an event notifying the extension.
   if (handler->HasPlugin()) {
     GURL handler_url(Extension::GetBaseURLFromExtensionId(extension_id).spec() +
                      handler->handler_url());
     int tab_id = ExtensionTabUtil::GetTabId(web_contents);
     std::unique_ptr<StreamContainer> stream_container(new StreamContainer(
         std::move(stream), tab_id, embedded, handler_url, extension_id));
     MimeHandlerStreamManager::Get(browser_context_)
-        ->AddStream(view_id, std::move(stream_container), render_process_id,
-                    render_frame_id);
+        ->AddStream(view_id, std::move(stream_container), frame_tree_node_id,
+                    render_process_id, render_frame_id);
     return;
   }
   // Create the event's arguments value.
   streams_private::StreamInfo info;
   info.mime_type = stream->mime_type;
   info.original_url = stream->original_url.spec();
   info.stream_url = stream->handle->GetURL().spec();
   info.tab_id = ExtensionTabUtil::GetTabId(web_contents);
   info.embedded = embedded;
 
@@ skipping 68 matching lines @@
 static base::LazyInstance<BrowserContextKeyedAPIFactory<StreamsPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<StreamsPrivateAPI>*
 StreamsPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 }  // namespace extensions