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

content/browser/loader/buffered_resource_handler_unittest.cc

Index: content/browser/loader/buffered_resource_handler_unittest.cc
diff --git a/content/browser/loader/buffered_resource_handler_unittest.cc b/content/browser/loader/buffered_resource_handler_unittest.cc
index e4d3668c371ff059657b48868c2a574c6f97dd13..4cc4ea5545b0387f1f88c5b86c1fdce2806891f9 100644
--- a/content/browser/loader/buffered_resource_handler_unittest.cc
+++ b/content/browser/loader/buffered_resource_handler_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "content/browser/loader/buffered_resource_handler.h"
 
+#include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
@@ -12,6 +13,7 @@
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/resource_response.h"
+#include "content/public/common/webplugininfo.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "content/test/fake_plugin_service.h"
@@ -99,6 +101,7 @@ class TestResourceDispatcherHost : public ResourceDispatcherHostImpl {
   }
 
   scoped_ptr<ResourceHandler> MaybeInterceptAsStream(
+      const base::FilePath& plugin_path,
       net::URLRequest* request,
       ResourceResponse* response,
       std::string* payload) override {
@@ -151,14 +154,54 @@ class TestResourceController : public ResourceController {
   }
 };
 
+class TestFakePluginService : public FakePluginService {
+ public:
+  explicit TestFakePluginService(bool plugin_available, bool is_plugin_stale)

[mmenke, 2015/03/25 14:11:44]

nit:  Explicit no longer needed.

[Deepak, 2015/03/26 04:55:12]

Done.

+      : plugin_available_(plugin_available),
+        is_plugin_stale_(is_plugin_stale) {}
+
+  bool 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) override {
+    *is_stale = is_plugin_stale_;
+    if (!plugin_available_)
+      return false;
+    info->type = WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN;
+    info->path = base::FilePath::FromUTF8Unsafe(
+        std::string("chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai/"));
+    return true;
+  }
+
+ private:
+  const bool plugin_available_;
+  const bool is_plugin_stale_;
+  DISALLOW_COPY_AND_ASSIGN(TestFakePluginService);

[Deepak, 2015/03/26 04:55:12]

Done.

+};
+
 class BufferedResourceHandlerTest : public testing::Test {
  public:
-  BufferedResourceHandlerTest() : stream_has_handler_(false) {}
+  BufferedResourceHandlerTest()
+      : stream_has_handler_(false),
+        plugin_available_(false),
+        plugin_stale_(false) {}
 
   void set_stream_has_handler(bool stream_has_handler) {
     stream_has_handler_ = stream_has_handler;
   }
 
+  void set_plugin_available(bool plugin_available) {
+    plugin_available_ = plugin_available;
+  }
+
+  void set_plugin_stale(bool plugin_stale) { plugin_stale_ = plugin_stale; }
+
   bool TestStreamIsIntercepted(bool allow_download,
                                bool must_download,
                                ResourceType request_resource_type);
@@ -166,6 +209,8 @@ class BufferedResourceHandlerTest : public testing::Test {
  private:
   // Whether the URL request should be intercepted as a stream.
   bool stream_has_handler_;
+  bool plugin_available_;
+  bool plugin_stale_;
 
   TestBrowserThreadBundle thread_bundle_;
 };
@@ -194,7 +239,7 @@ bool BufferedResourceHandlerTest::TestStreamIsIntercepted(
   TestResourceDispatcherHostDelegate host_delegate(must_download);
   host.SetDelegate(&host_delegate);
 
-  FakePluginService plugin_service;
+  TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
   scoped_ptr<ResourceHandler> buffered_handler(
       new BufferedResourceHandler(
           scoped_ptr<ResourceHandler>(new TestResourceHandler()).Pass(),
@@ -227,6 +272,8 @@ TEST_F(BufferedResourceHandlerTest, StreamHandling) {
   // ResourceDispatcherHost.
   set_stream_has_handler(true);
 
+  set_plugin_available(true);
+  set_plugin_stale(false);

[mmenke, 2015/03/25 14:11:44]

optional nit:  This is the default, so no need to set it.

[Deepak, 2015/03/26 04:55:11]

Done.

   // Main frame request with no download allowed. Stream shouldn't be
   // intercepted.
   allow_download = false;
@@ -279,6 +326,30 @@ TEST_F(BufferedResourceHandlerTest, StreamHandling) {
   resource_type = RESOURCE_TYPE_MAIN_FRAME;
   EXPECT_FALSE(
       TestStreamIsIntercepted(allow_download, must_download, resource_type));
+
+  // Test the cases where the stream handled by MaybeInterceptAsStream
+  // with plugin not available. This is the case when intercepting streams for
+  // the streamsPrivate extensions API.
+  set_stream_has_handler(true);
+  allow_download = false;
+  must_download = false;
+  resource_type = RESOURCE_TYPE_OBJECT;
+  set_plugin_available(false);
+  set_plugin_stale(false);
+  EXPECT_TRUE(
+      TestStreamIsIntercepted(allow_download, must_download, resource_type));
+
+  // Test the cases where the stream handled by MaybeInterceptAsStream
+  // with plugin not available. This is the case when intercepting streams for
+  // the streamsPrivate extensions API with stale plugin.
+  set_stream_has_handler(true);
+  allow_download = false;
+  must_download = false;
+  set_plugin_available(false);
+  set_plugin_stale(true);
+  resource_type = RESOURCE_TYPE_OBJECT;
+  EXPECT_FALSE(
+      TestStreamIsIntercepted(allow_download, must_download, resource_type));

[mmenke, 2015/03/25 14:11:44]

I'm not familiar with this test fixture, but is there a way we can make sure
it's intercepted asynchronously, once the plugin list is "updated"?

[raymes, 2015/03/25 23:32:08]

If we understood how the resume request process worked we could probably write a
test for it, but I don't know what function gets called into to resume the
request. Possibly OnResponseStarted just gets called again but I'm not
completely sure.

[Deepak, 2015/03/26 04:55:11]

It appears,in actual scenerio GetPlugins() in plugin_service_impl.cc binds
GetPluginInternal() which actually calls 
callback function in OnPluginLoaded().
But In Fake_plugin_service.cc GetPlugin() is empty and does not register any
callback. as it does not have GetPluginInternal() also.
so no callback is getting called.But I am not sure.

[mmenke, 2015/03/26 14:59:27]

So we can just override FakePluginService::GetPlugins and have it asynchronously
invoke the callback passed to it, and set is_plugin_state_ to false.

May also need to call content::RunAllPendingInMessageLoop twice instead of once,
or find some other more aggressive way to run tasks.  Or it may just work.  It's
unclear.

Sound reasonable?

Know not testing this isn't a result of your new code, but I feel the current
testing is pretty inadequate, and it a case your CL affects.

 }
 
 }  // namespace