Enable pepper flash by default in windows canary

chrome/browser/component_updater/pepper_flash_component_installer.cc

 // Copyright (c) 2011 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/component_updater/flash_component_installer.h"
 
 #include <string.h>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "build/build_config.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/browser/plugin_prefs.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/installer/util/browser_distribution.h"
 #include "content/browser/plugin_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "ppapi/c/private/ppb_pdf.h"
 #include "webkit/plugins/plugin_constants.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 
 using content::BrowserThread;
 
 namespace {
@@ skipping 37 matching lines @@
     "???";
 #endif
 
 // The Pepper Flash plugins are in a directory with this name.
 const FilePath::CharType kPepperFlashBaseDirectory[] =
     FILE_PATH_LITERAL("PepperFlash");
 
 // If we don't have a Pepper Flash component, this is the version we claim.
 const char kNullVersion[] = "0.0.0.0";
 
-// True if Pepper Flash should be enabled by default.
+// True if Pepper Flash should be enabled by default. Aura builds for any OS
+// and Windows canary have it enabled by default.
+bool IsPepperFlashEnabledByDefault() {
 #if defined(USE_AURA)
-const bool kEnablePepperFlash = true;
+  return true;
+#elif !defined(OS_WIN)
+  return false;
 #else
-const bool kEnablePepperFlash = false;
+  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
+  if (!dist)
+    return false;
+  string16 channel;
+  if (!dist->GetChromeChannel(&channel))
+    return false;
+  return (channel == L"canary");
 #endif
+}
 
 // The base directory on Windows looks like:
 // <profile>\AppData\Local\Google\Chrome\User Data\PepperFlash\.
 FilePath GetPepperFlashBaseDirectory() {
   FilePath result;
   PathService::Get(chrome::DIR_USER_DATA, &result);
   return result.Append(kPepperFlashBaseDirectory);
 }
 
 // Pepper Flash plugins have the version encoded in the path itself
@@ skipping 56 matching lines @@
                                           kFlashPluginSwfExtension,
                                           kFlashPluginName);
   plugin_info->mime_types.push_back(swf_mime_type);
   webkit::WebPluginMimeType spl_mime_type(kFlashPluginSplMimeType,
                                           kFlashPluginSplExtension,
                                           kFlashPluginName);
   plugin_info->mime_types.push_back(spl_mime_type);
   return true;
 }
 
+// If it is a |fresh_install| we enable or disable it by default in some
+// configurations. See IsPepperFlashEnabledByDefault() for more information.
 void RegisterPepperFlashWithChrome(const FilePath& path,
-                                   const Version& version) {
+                                   const Version& version,
+                                   bool fresh_install) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::PepperPluginInfo plugin_info;
-  // Register it as out-of-process and disabled.
   if (!MakePepperFlashPluginInfo(path, version, true, &plugin_info))
     return;
-  PluginPrefs::EnablePluginGlobally(kEnablePepperFlash, plugin_info.path);
+  if (fresh_install) {
+    PluginPrefs::EnablePluginGlobally(IsPepperFlashEnabledByDefault(),
+                                      plugin_info.path);
+  }
   PluginService::GetInstance()->RegisterInternalPlugin(
       plugin_info.ToWebPluginInfo());
   PluginService::GetInstance()->RefreshPlugins();
 }
 
 }  // namespace
 
 class PepperFlashComponentInstaller : public ComponentInstaller {
  public:
   explicit PepperFlashComponentInstaller(const Version& version);
@@ skipping 34 matching lines @@
     return false;
   if (!file_util::Move(unpack_path, path))
     return false;
   // Installation is done. Now tell the rest of chrome. Both the path service
   // and to the plugin service.
   current_version_ = version;
   path = path.Append(kPepperFlashPluginFileName);
   PathService::Override(chrome::FILE_PEPPER_FLASH_PLUGIN, path);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&RegisterPepperFlashWithChrome, path, version));
+      base::Bind(&RegisterPepperFlashWithChrome, path, version, true));
   return true;
 }
 
 bool VetoPepperFlashIntefaces(base::DictionaryValue* manifest) {
   // Check that we implement the required interfaces.
   base::ListValue* interfaces = NULL;
   if (manifest->GetList("x-ppapi-required-interfaces", &interfaces)) {
     for (size_t ix = 0; ix != interfaces->GetSize(); ++ix) {
       std::string interface_name;
       if (!interfaces->GetString(ix, &interface_name))
@@ skipping 68 matching lines @@
       return;
     }
   }
 
   Version version(kNullVersion);
   if (GetLatestPepperFlashDirectory(&path, &version)) {
     path = path.Append(kPepperFlashPluginFileName);
     if (file_util::PathExists(path)) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
-          base::Bind(&RegisterPepperFlashWithChrome, path, version));
+          base::Bind(&RegisterPepperFlashWithChrome, path, version, false));
     } else {
       version = Version(kNullVersion);
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&FinishPepperFlashUpdateRegistration, cus, version));
 }
 
 }  // namespace
 
 void RegisterPepperFlashComponent(ComponentUpdateService* cus) {
-// #if defined(GOOGLE_CHROME_BUILD)
+#if defined(GOOGLE_CHROME_BUILD)
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&StartPepperFlashUpdateRegistration, cus));
-// #endif
+#endif
 }