Ensuring interception of stream get determined by plugin path before checking mime type.

content/test/fake_plugin_service.cc

 // Copyright 2014 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/test/fake_plugin_service.h"
 
+#include "content/public/common/webplugininfo.h"
+
 namespace content {
 
 FakePluginService::FakePluginService() {
 }
 
+FakePluginService::FakePluginService(bool is_plugin_available)
+    : is_plugin_available_(is_plugin_available) {
+}
+
 FakePluginService::~FakePluginService() {
 }
 
 void FakePluginService::Init() {
 }
 
 void FakePluginService::StartWatchingPlugins() {
 }
 
 bool FakePluginService::GetPluginInfoArray(
     const GURL& url,
     const std::string& mime_type,
     bool allow_wildcard,
     std::vector<WebPluginInfo>* plugins,
     std::vector<std::string>* actual_mime_types) {
   return false;
 }
 
 bool FakePluginService::GetPluginInfo(int render_process_id,
                                       int render_frame_id,
                                       ResourceContext* context,
                                       const GURL& url,
                                       const GURL& page_url,
                                       const std::string& mime_type,
                                       bool allow_wildcard,
                                       bool* is_stale,
                                       WebPluginInfo* info,
                                       std::string* actual_mime_type) {
   *is_stale = false;
-  return false;
+  if (!is_plugin_available_)
+    return false;
+  info->type = WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN;
+  info->path = base::FilePath();

[raymes, 2015/03/19 00:45:51]

If a plugin is available, shouldn't we return a valid plugin path? Otherwise we
won't hit that codepath right?

[Deepak, 2015/03/19 10:22:23]

Even when we give the proper plugin path then also,
TestResourceDispatcherHost::MaybeInterceptAsStream() in
buffered_resource_handler_unittest.cc get called not the actual 
ResourceDispatcherHostImpl::MaybeInterceptAsStream().
As this is just simulation that MaybeInterceptAsStream() calling.
For completeness I am assigning proper plugin path when plugin available as
suggested.

+  return true;

[raymes, 2015/03/19 00:45:51]

Rather than adding this stuff here, I think we should have a separate class
defined inside the unittest which inherits from FakePluginService and overrides
this method.

[Deepak, 2015/03/19 10:22:23]

Done.

 }
 
 bool FakePluginService::GetPluginInfoByPath(const base::FilePath& plugin_path,
                                             WebPluginInfo* info) {
   return false;
 }
 
 base::string16 FakePluginService::GetPluginDisplayNameByPath(
     const base::FilePath& path) {
   return base::string16();
@@ skipping 67 matching lines @@
 }
 #endif
 
 bool FakePluginService::PpapiDevChannelSupported(
     BrowserContext* browser_context,
     const GURL& document_url) {
   return false;
 }
 
 }  // namespace content