Make the logic for stream interception by MimeHandlerViews consistent with starting the plugin

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 189 matching lines @@
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 
   StreamsPrivateAPI* streams_private = StreamsPrivateAPI::Get(profile);
   if (!streams_private)
     return;
   streams_private->ExecuteMimeTypeHandler(
       extension_id, web_contents, stream.Pass(), view_id, expected_content_size,
       embedded, render_process_id, render_frame_id);
 }
-
-// TODO(raymes): This won't return the right result if plugins haven't been
-// loaded yet. Fixing this properly really requires fixing crbug.com/443466.
-bool IsPluginEnabledForExtension(const Extension* extension,
-                                 const ResourceRequestInfo* info,
-                                 const std::string& mime_type,
-                                 const GURL& url) {
-  content::PluginService* service = content::PluginService::GetInstance();
-  std::vector<content::WebPluginInfo> plugins;
-  service->GetPluginInfoArray(url, mime_type, true, &plugins, nullptr);
-  content::PluginServiceFilter* filter = service->GetFilter();
-
-  for (auto& plugin : plugins) {
-    // Check that the plugin is running the extension.
-    if (plugin.path !=
-        base::FilePath::FromUTF8Unsafe(extension->url().spec())) {
-      continue;
-    }
-    // Check that the plugin is actually enabled.
-    if (!filter || filter->IsPluginAvailable(info->GetChildID(),
-                                             info->GetRenderFrameID(),
-                                             info->GetContext(),
-                                             url,
-                                             GURL(),
-                                             &plugin)) {
-      return true;
-    }
-  }
-  return false;
-}
 #endif  // !defined(ENABLE_EXTENSIONS)
 
 void LaunchURL(
     const GURL& url,
     int render_process_id,
     int render_view_id,
     ui::PageTransition page_transition,
     bool has_user_gesture) {
   // If there is no longer a WebContents, the request may have raced with tab
   // closing. Don't fire the external request. (It may have been a prerender.)
@@ skipping 364 matching lines @@
 #if defined(ENABLE_EXTENSIONS)
   // Special-case user scripts to get downloaded instead of viewed.
   return extensions::UserScript::IsURLUserScript(url, mime_type);
 #else
   return false;
 #endif
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream(
     net::URLRequest* request,
+    const base::FilePath& plugin_path,
     const std::string& mime_type,
     GURL* origin,
     std::string* payload) {
 #if defined(ENABLE_EXTENSIONS)
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   ProfileIOData* io_data =
       ProfileIOData::FromResourceContext(info->GetContext());
   bool profile_is_off_the_record = io_data->IsOffTheRecord();
   const scoped_refptr<const extensions::InfoMap> extension_info_map(
       io_data->GetExtensionInfoMap());
   std::vector<std::string> whitelist = MimeTypesHandler::GetMIMETypeWhitelist();
   // Go through the white-listed extensions and try to use them to intercept
   // the URL request.
   for (const std::string& extension_id : whitelist) {
     const Extension* extension =
         extension_info_map->extensions().GetByID(extension_id);
     // The white-listed extension may not be installed, so we have to NULL check
     // |extension|.
     if (!extension ||
         (profile_is_off_the_record &&
          !extension_info_map->IsIncognitoEnabled(extension_id))) {
       continue;
     }
+    MimeTypesHandler* handler = MimeTypesHandler::GetHandler(extension);
+    if (!handler)
+      continue;
 
-    MimeTypesHandler* handler = MimeTypesHandler::GetHandler(extension);
-    if (handler && handler->CanHandleMIMEType(mime_type)) {
-      StreamTargetInfo target_info;
-      *origin = Extension::GetBaseURLFromExtensionId(extension_id);
-      target_info.extension_id = extension_id;
-      if (!handler->handler_url().empty()) {
-        // This is reached in the case of MimeHandlerViews. If the
-        // MimeHandlerView plugin is disabled, then we shouldn't intercept the
-        // stream.
-        if (!IsPluginEnabledForExtension(extension, info, mime_type,
-                                         request->url())) {
-          continue;
-        }
+    // If a plugin path is provided then we are trying to intercept the stream

[mmenke, 2015/07/09 20:35:39]

nit:  SHouldn't use we in comments.

[raymes, 2015/07/17 03:21:00]

Done.

+    // for the mimeHandlerPrivate API. Otherwise we are trying to intercept the
+    // stream for the streamsPrivate API.
+    if (!plugin_path.empty()) {
+      // Check that the plugin path matches the handlers plugin path.
+      if (handler->HasPlugin() && plugin_path == handler->GetPluginPath()) {
+        StreamTargetInfo target_info;
+        *origin = Extension::GetBaseURLFromExtensionId(extension_id);
+        target_info.extension_id = extension_id;
         target_info.view_id = base::GenerateGUID();
         *payload = target_info.view_id;
+        stream_target_info_[request] = target_info;
+        return true;
       }
-      stream_target_info_[request] = target_info;
-      return true;
+    } else {

[Sam McNally, 2015/07/07 06:44:28]

else if

[raymes, 2015/07/17 03:21:00]

Done. I reworked the code slightly

+      if (!handler->HasPlugin() && handler->CanHandleMIMEType(mime_type)) {
+        StreamTargetInfo target_info;
+        *origin = Extension::GetBaseURLFromExtensionId(extension_id);
+        target_info.extension_id = extension_id;
+        stream_target_info_[request] = target_info;
+        return true;
+      }
     }
   }
 #endif
   return false;
 }
 
 void ChromeResourceDispatcherHostDelegate::OnStreamCreated(
     net::URLRequest* request,
     scoped_ptr<content::StreamInfo> stream) {
 #if defined(ENABLE_EXTENSIONS)
@@ skipping 104 matching lines @@
                                        url_request->GetTotalReceivedBytes()));
   }
 }
 
 // static
 void ChromeResourceDispatcherHostDelegate::
     SetExternalProtocolHandlerDelegateForTesting(
     ExternalProtocolHandler::Delegate* delegate) {
   g_external_protocol_handler_delegate = delegate;
 }