Move click-to-play to about:flags.

chrome/browser/host_content_settings_map.cc

 // Copyright (c) 2010 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/host_content_settings_map.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_thread.h"
@@ skipping 373 matching lines @@
     }
     const size_t next_dot = key.find('.', kDomainWildcardLength);
     if (next_dot == std::string::npos)
       break;
     key.erase(kDomainWildcardLength, next_dot - kDomainWildcardLength + 1);
   }
 
   return output;
 }
 
+ContentSetting HostContentSettingsMap::ClickToPlayFixup(
+    ContentSettingsType content_type,
+    ContentSetting setting) {
+  if (setting == CONTENT_SETTING_ASK &&
+      content_type == CONTENT_SETTINGS_TYPE_PLUGINS &&
+      !CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableClickToPlay)) {
+    return CONTENT_SETTING_BLOCK;
+  }
+  return setting;
+}
+
 void HostContentSettingsMap::GetSettingsForOneType(
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     SettingsForOneType* settings) const {
   DCHECK(RequiresResourceIdentifier(content_type) !=
          resource_identifier.empty());
   DCHECK(settings);
   settings->clear();
 
   const HostContentSettings* map_to_return =
@@ skipping 21 matching lines @@
       settings->push_back(std::make_pair(Pattern(i->first), setting));
     }
   }
 }
 
 void HostContentSettingsMap::SetDefaultContentSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(content_type != CONTENT_SETTINGS_TYPE_PLUGINS ||
+         setting != CONTENT_SETTING_ASK ||
+         CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableClickToPlay));
   PrefService* prefs = profile_->GetPrefs();
 
   // The default settings may not be directly modified for OTR sessions.
   // Instead, they are synced to the main profile's setting.
   if (is_off_the_record_) {
     NOTREACHED();
     return;
   }
 
   DictionaryValue* default_settings_dictionary =
@@ skipping 22 matching lines @@
 
 void HostContentSettingsMap::SetContentSetting(
     const Pattern& original_pattern,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     ContentSetting setting) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_NE(RequiresResourceIdentifier(content_type),
             resource_identifier.empty());
+  DCHECK(content_type != CONTENT_SETTINGS_TYPE_PLUGINS ||
+         setting != CONTENT_SETTING_ASK ||
+         CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableClickToPlay));
 
   const Pattern pattern(original_pattern.CanonicalizePattern());
 
   bool early_exit = false;
   std::string pattern_str(pattern.AsString());
   PrefService* prefs = NULL;
   DictionaryValue* all_settings_dictionary = NULL;
   HostContentSettings* map_to_modify = &off_the_record_settings_;
   if (!is_off_the_record_) {
     prefs = profile_->GetPrefs();
@@ skipping 302 matching lines @@
         DCHECK(found);
         settings->settings[type] = IntToContentSetting(setting);
         break;
       }
     }
   }
   // Migrate obsolete cookie prompt mode.
   if (settings->settings[CONTENT_SETTINGS_TYPE_COOKIES] ==
       CONTENT_SETTING_ASK)
     settings->settings[CONTENT_SETTINGS_TYPE_COOKIES] = CONTENT_SETTING_BLOCK;
+
+  settings->settings[CONTENT_SETTINGS_TYPE_PLUGINS] =
+      ClickToPlayFixup(CONTENT_SETTINGS_TYPE_PLUGINS,
+                       settings->settings[CONTENT_SETTINGS_TYPE_PLUGINS]);
 }
 
 void HostContentSettingsMap::GetResourceSettingsFromDictionary(
     const DictionaryValue* dictionary,
     ResourceContentSettings* settings) {
   for (DictionaryValue::key_iterator i(dictionary->begin_keys());
        i != dictionary->end_keys(); ++i) {
     const std::string& content_type(*i);
     for (size_t type = 0; type < arraysize(kResourceTypeNames); ++type) {
       if ((kResourceTypeNames[type] != NULL) &&
           (kResourceTypeNames[type] == content_type)) {
         DictionaryValue* resource_dictionary = NULL;
         bool found = dictionary->GetDictionary(content_type,
                                                &resource_dictionary);
         DCHECK(found);
         for (DictionaryValue::key_iterator j(resource_dictionary->begin_keys());
              j != resource_dictionary->end_keys(); ++j) {
           const std::string& resource_identifier(*j);
           int setting = CONTENT_SETTING_DEFAULT;
           bool found = resource_dictionary->GetIntegerWithoutPathExpansion(
               resource_identifier, &setting);
           DCHECK(found);
           (*settings)[ContentSettingsTypeResourceIdentifierPair(
               ContentSettingsType(type), resource_identifier)] =
-                  ContentSetting(setting);
+                  ClickToPlayFixup(ContentSettingsType(type),
+                                   ContentSetting(setting));
         }
 
         break;
       }
     }
   }
 }
 
 void HostContentSettingsMap::ForceDefaultsToBeExplicit() {
   DCHECK_EQ(arraysize(kDefaultSettings),
@@ skipping 172 matching lines @@
   }
 
   for (size_t i = 0; i < move_items.size(); ++i) {
     Value* pattern_settings_dictionary = NULL;
     all_settings_dictionary->RemoveWithoutPathExpansion(
         move_items[i].first, &pattern_settings_dictionary);
     all_settings_dictionary->SetWithoutPathExpansion(
         move_items[i].second, pattern_settings_dictionary);
   }
 }