[HBD] Blanket BLOCK on all non-HTTP(s) and non-FILE URLs for Flash.

chrome/browser/plugins/plugin_info_message_filter_unittest.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 "chrome/browser/plugins/plugin_info_message_filter.h"
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/plugins/plugin_utils.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/plugin_service_filter.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/origin.h"
 
 using content::PluginService;
 
 namespace {
 
 void PluginsLoaded(const base::Closure& callback,
                    const std::vector<content::WebPluginInfo>& plugins) {
   callback.Run();
 }
 
 class FakePluginServiceFilter : public content::PluginServiceFilter {
  public:
   FakePluginServiceFilter() {}
   ~FakePluginServiceFilter() override {}
 
   bool IsPluginAvailable(int render_process_id,
                          int render_view_id,
                          const void* context,
                          const GURL& url,
-                         const GURL& policy_url,
+                         const url::Origin& main_frame_origin,
                          content::WebPluginInfo* plugin) override;
 
   bool CanLoadPlugin(int render_process_id,
                      const base::FilePath& path) override;
 
   void set_plugin_enabled(const base::FilePath& plugin_path, bool enabled) {
     plugin_state_[plugin_path] = enabled;
   }
 
  private:
   std::map<base::FilePath, bool> plugin_state_;
 };
 
 bool FakePluginServiceFilter::IsPluginAvailable(
     int render_process_id,
     int render_view_id,
     const void* context,
     const GURL& url,
-    const GURL& policy_url,
+    const url::Origin& main_frame_origin,
     content::WebPluginInfo* plugin) {
   std::map<base::FilePath, bool>::iterator it =
       plugin_state_.find(plugin->path);
   if (it == plugin_state_.end()) {
     ADD_FAILURE() << "No plugin state for '" << plugin->path.value() << "'";
     return false;
   }
   return it->second;
 }
 
@@ skipping 66 matching lines @@
     ContentSetting setting = expected_setting == CONTENT_SETTING_DEFAULT ?
         CONTENT_SETTING_BLOCK : CONTENT_SETTING_DEFAULT;
     bool is_default = !expected_is_default;
     bool is_managed = !expected_is_managed;
 
     // Pass in a fake Flash plugin info.
     content::WebPluginInfo plugin_info(
         base::ASCIIToUTF16(content::kFlashPluginName), base::FilePath(),
         base::ASCIIToUTF16("1"), base::ASCIIToUTF16("Fake Flash"));
 
-    PluginUtils::GetPluginContentSetting(host_content_settings_map_,
-                                         plugin_info, url, url, plugin,
-                                         &setting, &is_default, &is_managed);
+    PluginUtils::GetPluginContentSetting(
+        host_content_settings_map_, plugin_info, url::Origin(url), url, plugin,
+        &setting, &is_default, &is_managed);
     EXPECT_EQ(expected_setting, setting);
     EXPECT_EQ(expected_is_default, is_default);
     EXPECT_EQ(expected_is_managed, is_managed);
   }
 
   base::FilePath foo_plugin_path_;
   base::FilePath bar_plugin_path_;
   FakePluginServiceFilter filter_;
 
  private:
   base::ShadowingAtExitManager at_exit_manager_;  // Destroys the PluginService.
   content::TestBrowserThreadBundle test_thread_bundle;
   TestingProfile profile_;
   PluginInfoMessageFilter::Context context_;
   HostContentSettingsMap* host_content_settings_map_;
 };
 
 TEST_F(PluginInfoMessageFilterTest, FindEnabledPlugin) {
   filter_.set_plugin_enabled(foo_plugin_path_, true);
   filter_.set_plugin_enabled(bar_plugin_path_, true);
   {
     ChromeViewHostMsg_GetPluginInfo_Status status;
     content::WebPluginInfo plugin;
     std::string actual_mime_type;
-    EXPECT_TRUE(context()->FindEnabledPlugin(
-        0, GURL(), GURL(), "foo/bar", &status, &plugin, &actual_mime_type,
-        NULL));
+    EXPECT_TRUE(context()->FindEnabledPlugin(0, GURL(), url::Origin(),
+                                             "foo/bar", &status, &plugin,
+                                             &actual_mime_type, NULL));
     EXPECT_EQ(ChromeViewHostMsg_GetPluginInfo_Status::kAllowed, status);
     EXPECT_EQ(foo_plugin_path_.value(), plugin.path.value());
   }
 
   filter_.set_plugin_enabled(foo_plugin_path_, false);
   {
     ChromeViewHostMsg_GetPluginInfo_Status status;
     content::WebPluginInfo plugin;
     std::string actual_mime_type;
-    EXPECT_TRUE(context()->FindEnabledPlugin(
-        0, GURL(), GURL(), "foo/bar", &status, &plugin, &actual_mime_type,
-        NULL));
+    EXPECT_TRUE(context()->FindEnabledPlugin(0, GURL(), url::Origin(),
+                                             "foo/bar", &status, &plugin,
+                                             &actual_mime_type, NULL));
     EXPECT_EQ(ChromeViewHostMsg_GetPluginInfo_Status::kAllowed, status);
     EXPECT_EQ(bar_plugin_path_.value(), plugin.path.value());
   }
 
   filter_.set_plugin_enabled(bar_plugin_path_, false);
   {
     ChromeViewHostMsg_GetPluginInfo_Status status;
     content::WebPluginInfo plugin;
     std::string actual_mime_type;
     std::string identifier;
     base::string16 plugin_name;
-    EXPECT_FALSE(context()->FindEnabledPlugin(
-        0, GURL(), GURL(), "foo/bar", &status, &plugin, &actual_mime_type,
-        NULL));
+    EXPECT_FALSE(context()->FindEnabledPlugin(0, GURL(), url::Origin(),
+                                              "foo/bar", &status, &plugin,
+                                              &actual_mime_type, NULL));
     EXPECT_EQ(ChromeViewHostMsg_GetPluginInfo_Status::kDisabled, status);
     EXPECT_EQ(foo_plugin_path_.value(), plugin.path.value());
   }
   {
     ChromeViewHostMsg_GetPluginInfo_Status status;
     content::WebPluginInfo plugin;
     std::string actual_mime_type;
-    EXPECT_FALSE(context()->FindEnabledPlugin(
-        0, GURL(), GURL(), "baz/blurp", &status, &plugin, &actual_mime_type,
-        NULL));
+    EXPECT_FALSE(context()->FindEnabledPlugin(0, GURL(), url::Origin(),
+                                              "baz/blurp", &status, &plugin,
+                                              &actual_mime_type, NULL));
     EXPECT_EQ(ChromeViewHostMsg_GetPluginInfo_Status::kNotFound, status);
     EXPECT_EQ(FILE_PATH_LITERAL(""), plugin.path.value());
   }
 }
 
 TEST_F(PluginInfoMessageFilterTest, GetPluginContentSetting) {
   HostContentSettingsMap* map =
       HostContentSettingsMapFactory::GetForProfile(profile());
 
   // Block plugins by default.
@@ skipping 40 matching lines @@
       profile()->GetTestingPrefService();
   prefs->SetManagedPref(prefs::kManagedDefaultPluginsSetting,
                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 
   // All plugins should be blocked now.
   VerifyPluginContentSetting(host, "foo", CONTENT_SETTING_BLOCK, true, true);
   VerifyPluginContentSetting(host, "bar", CONTENT_SETTING_BLOCK, true, true);
   VerifyPluginContentSetting(unmatched_host, "bar", CONTENT_SETTING_BLOCK,
                              true, true);
 }