Revert of media: Add helper function to register pepper CDMs

chrome/browser/content_settings/content_settings_browsertest.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 "base/command_line.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 25 matching lines @@
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
-#if defined(ENABLE_PEPPER_CDMS)
-#include "chrome/browser/media/pepper_cdm_test_helper.h"
-#endif
-
 using content::BrowserThread;
 using net::URLRequestMockHTTPJob;
 
 namespace {
 
 const LocalSharedObjectsContainer* GetSiteSettingsCookieContainer(
     Browser* browser) {
   TabSpecificContentSettings* settings =
       TabSpecificContentSettings::FromWebContents(
           browser->tab_strip_model()->GetWebContentsAt(0));
@@ skipping 254 matching lines @@
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   EXPECT_TRUE(TabSpecificContentSettings::FromWebContents(web_contents)->
       IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 }
 
 #if defined(ENABLE_PLUGINS)
 class PepperContentSettingsSpecialCasesTest : public ContentSettingsTest {
  protected:
+  static const char kExternalClearKeyMimeType[];
+
   // Registers any CDM plugins not registered by default.
   void SetUpCommandLine(base::CommandLine* command_line) override {
 #if defined(ENABLE_PEPPER_CDMS)
+    // Platform-specific filename relative to the chrome executable.
+#if defined(OS_WIN)
+    const char kLibraryName[] = "clearkeycdmadapter.dll";
+#else  // !defined(OS_WIN)
+#if defined(OS_MACOSX)
+    const char kLibraryName[] = "clearkeycdmadapter.plugin";
+#elif defined(OS_POSIX)
+    const char kLibraryName[] = "libclearkeycdmadapter.so";
+#endif  // defined(OS_MACOSX)
+#endif  // defined(OS_WIN)
+
     // Append the switch to register the External Clear Key CDM.
-    base::FilePath::StringType pepper_plugins = BuildPepperCdmRegistration(
-        kClearKeyCdmAdapterFileName, kClearKeyCdmPepperMimeType);
+    base::FilePath::StringType pepper_plugins = BuildPepperPluginRegistration(
+        kLibraryName, "Clear Key CDM", kExternalClearKeyMimeType);
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
     // The CDM must be registered when it is a component.
     pepper_plugins.append(FILE_PATH_LITERAL(","));
-    pepper_plugins.append(BuildPepperCdmRegistration(
-        kWidevineCdmAdapterFileName, kWidevineCdmPluginMimeType));
+    pepper_plugins.append(
+        BuildPepperPluginRegistration(kWidevineCdmAdapterFileName,
+                                      kWidevineCdmDisplayName,
+                                      kWidevineCdmPluginMimeType));
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
     command_line->AppendSwitchNative(switches::kRegisterPepperPlugins,
                                      pepper_plugins);
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 #if !defined(DISABLE_NACL)
     // Ensure NaCl can run.
     command_line->AppendSwitch(switches::kEnableNaCl);
 #endif
   }
@@ skipping 65 matching lines @@
       // false, javascript_content_blocked_observer would never succeed.
       // There is no way to ensure blocked content would not have been reported
       // after the check below. For coverage of this scenario, we must rely on
       // the TitleWatcher adding sufficient delay most of the time.
     }
 
     EXPECT_EQ(expect_is_javascript_content_blocked,
               tab_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_JAVASCRIPT));
     EXPECT_FALSE(tab_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_PLUGINS));
   }
+
+ private:
+  // Builds the string to pass to kRegisterPepperPlugins for a single
+  // plugin using the provided parameters and a dummy version.
+  // Multiple results may be passed to kRegisterPepperPlugins, separated by ",".
+  base::FilePath::StringType BuildPepperPluginRegistration(
+      const char* library_name,
+      const char* display_name,
+      const char* mime_type) {
+    base::FilePath plugin_dir;
+    EXPECT_TRUE(PathService::Get(base::DIR_MODULE, &plugin_dir));
+
+    base::FilePath plugin_lib = plugin_dir.AppendASCII(library_name);
+    EXPECT_TRUE(base::PathExists(plugin_lib));
+
+    base::FilePath::StringType pepper_plugin = plugin_lib.value();
+    std::string string_to_append = "#";
+    string_to_append.append(display_name);
+    string_to_append.append("#A CDM#0.1.0.0;");
+    string_to_append.append(mime_type);
+
+#if defined(OS_WIN)
+    pepper_plugin.append(base::ASCIIToUTF16(string_to_append));
+#else
+    pepper_plugin.append(string_to_append);
+#endif
+
+    return pepper_plugin;
+  }
 };
 
+const char
+PepperContentSettingsSpecialCasesTest::kExternalClearKeyMimeType[] =
+    "application/x-ppapi-clearkey-cdm";
+
 class PepperContentSettingsSpecialCasesPluginsBlockedTest
     : public PepperContentSettingsSpecialCasesTest {
  public:
   void SetUpOnMainThread() override {
     PepperContentSettingsSpecialCasesTest::SetUpOnMainThread();
     HostContentSettingsMapFactory::GetForProfile(browser()->profile())
         ->SetDefaultContentSetting(CONTENT_SETTINGS_TYPE_PLUGINS,
                                    CONTENT_SETTING_BLOCK);
   }
 };
@@ skipping 13 matching lines @@
 };
 
 #if defined(ENABLE_PEPPER_CDMS)
 // A sanity check to verify that the plugin that is used as a baseline below
 // can be loaded.
 IN_PROC_BROWSER_TEST_F(PepperContentSettingsSpecialCasesTest, Baseline) {
   HostContentSettingsMapFactory::GetForProfile(browser()->profile())
       ->SetDefaultContentSetting(CONTENT_SETTINGS_TYPE_PLUGINS,
                                  CONTENT_SETTING_ALLOW);
 
-  RunLoadPepperPluginTest(kClearKeyCdmPepperMimeType, true);
+  RunLoadPepperPluginTest(kExternalClearKeyMimeType, true);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 // The following tests verify that Pepper plugins that use JavaScript settings
 // instead of Plugins settings still work when Plugins are blocked.
 
 #if defined(ENABLE_PEPPER_CDMS)
 // The plugin successfully loaded above is blocked.
 IN_PROC_BROWSER_TEST_F(PepperContentSettingsSpecialCasesPluginsBlockedTest,
                        Normal) {
-  RunLoadPepperPluginTest(kClearKeyCdmPepperMimeType, false);
+  RunLoadPepperPluginTest(kExternalClearKeyMimeType, false);
 }
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && !defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(PepperContentSettingsSpecialCasesPluginsBlockedTest,
                        WidevineCdm) {
   RunLoadPepperPluginTest(kWidevineCdmPluginMimeType, true);
 }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && !defined(OS_CHROMEOS)
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
@@ skipping 23 matching lines @@
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 #if !defined(DISABLE_NACL)
 IN_PROC_BROWSER_TEST_F(PepperContentSettingsSpecialCasesJavaScriptBlockedTest,
                        NaCl) {
   RunJavaScriptBlockedTest("load_nacl_no_js.html", true);
 }
 #endif  // !defined(DISABLE_NACL)
 
 #endif  // defined(ENABLE_PLUGINS)