Revert 141482 - Pepper Flash settings integration - camera and microphone.

chrome/browser/ui/webui/options2/content_settings_handler2.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 "chrome/browser/ui/webui/options2/content_settings_handler2.h"
 
+#include <map>
+#include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
@@ skipping 15 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/common/content_switches.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
-#include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #endif
 
 using content::UserMetricsAction;
 
 namespace {
 
-enum ExContentSettingsTypeEnum {
-  EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC =
-      CONTENT_SETTINGS_NUM_TYPES,
-  EX_CONTENT_SETTINGS_NUM_TYPES
+struct ContentSettingsTypeNameEntry {
+  ContentSettingsType type;
+  const char* name;
 };
 
 typedef std::map<ContentSettingsPattern, ContentSetting> OnePatternSettings;
 typedef std::map<ContentSettingsPattern, OnePatternSettings>
     AllPatternsSettings;
 
 const char* kDisplayPattern = "displayPattern";
 const char* kSetting = "setting";
 const char* kOrigin = "origin";
 const char* kSource = "source";
 const char* kAppName = "appName";
 const char* kAppId = "appId";
 const char* kEmbeddingOrigin = "embeddingOrigin";
-const char* kDefaultProviderID = "default";
-const char* kPreferencesSource = "preferences";
+
+const ContentSettingsTypeNameEntry kContentSettingsTypeGroupNames[] = {
+  {CONTENT_SETTINGS_TYPE_COOKIES, "cookies"},
+  {CONTENT_SETTINGS_TYPE_IMAGES, "images"},
+  {CONTENT_SETTINGS_TYPE_JAVASCRIPT, "javascript"},
+  {CONTENT_SETTINGS_TYPE_PLUGINS, "plugins"},
+  {CONTENT_SETTINGS_TYPE_POPUPS, "popups"},
+  {CONTENT_SETTINGS_TYPE_GEOLOCATION, "location"},
+  {CONTENT_SETTINGS_TYPE_NOTIFICATIONS, "notifications"},
+  {CONTENT_SETTINGS_TYPE_INTENTS, "intents"},
+  {CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, "auto-select-certificate"},
+  {CONTENT_SETTINGS_TYPE_FULLSCREEN, "fullscreen"},
+  {CONTENT_SETTINGS_TYPE_MOUSELOCK, "mouselock"},
+};
+COMPILE_ASSERT(arraysize(kContentSettingsTypeGroupNames) ==
+                   CONTENT_SETTINGS_NUM_TYPES,
+               MISSING_CONTENT_SETTINGS_TYPE);
+
+ContentSettingsType ContentSettingsTypeFromGroupName(const std::string& name) {
+  for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
+    if (name == kContentSettingsTypeGroupNames[i].name)
+      return kContentSettingsTypeGroupNames[i].type;
+  }
+
+  NOTREACHED() << name << " is not a recognized content settings type.";
+  return CONTENT_SETTINGS_TYPE_DEFAULT;
+}
 
 std::string ContentSettingToString(ContentSetting setting) {
   switch (setting) {
     case CONTENT_SETTING_ALLOW:
       return "allow";
     case CONTENT_SETTING_ASK:
       return "ask";
     case CONTENT_SETTING_BLOCK:
       return "block";
     case CONTENT_SETTING_SESSION_ONLY:
@@ skipping 130 matching lines @@
     }
     // Retrieve the launch URL.
     std::string launch_url_string = (*extension)->launch_web_url();
     GURL launch_url(launch_url_string);
     // Skip adding the launch URL if it is part of the web extent.
     if (web_extent.MatchesURL(launch_url)) continue;
     AddExceptionForHostedApp(launch_url_string, **extension, exceptions);
   }
 }
 
-ContentSetting FlashPermissionToContentSetting(
-    PP_Flash_BrowserOperations_Permission permission) {
-  switch (permission) {
-    case PP_FLASH_BROWSEROPERATIONS_PERMISSION_DEFAULT:
-      return CONTENT_SETTING_DEFAULT;
-    case PP_FLASH_BROWSEROPERATIONS_PERMISSION_ALLOW:
-      return CONTENT_SETTING_ALLOW;
-    case PP_FLASH_BROWSEROPERATIONS_PERMISSION_BLOCK:
-      return CONTENT_SETTING_BLOCK;
-    case PP_FLASH_BROWSEROPERATIONS_PERMISSION_ASK:
-      return CONTENT_SETTING_ASK;
-    default:
-      NOTREACHED();
-      return CONTENT_SETTING_DEFAULT;
-  }
-}
-
-PP_Flash_BrowserOperations_Permission FlashPermissionFromContentSetting(
-    ContentSetting setting) {
-  switch (setting) {
-    case CONTENT_SETTING_DEFAULT:
-      return PP_FLASH_BROWSEROPERATIONS_PERMISSION_DEFAULT;
-    case CONTENT_SETTING_ALLOW:
-      return PP_FLASH_BROWSEROPERATIONS_PERMISSION_ALLOW;
-    case CONTENT_SETTING_BLOCK:
-      return PP_FLASH_BROWSEROPERATIONS_PERMISSION_BLOCK;
-    case CONTENT_SETTING_ASK:
-      return PP_FLASH_BROWSEROPERATIONS_PERMISSION_ASK;
-    default:
-      NOTREACHED();
-      return PP_FLASH_BROWSEROPERATIONS_PERMISSION_DEFAULT;
-  }
-}
-
-std::string CanonicalizeHost(const std::string& host) {
-  url_canon::CanonHostInfo info;
-  return net::CanonicalizeHost(host, &info);
-}
-
-bool IsValidHost(const std::string& host) {
-  std::string canonicalized_host = CanonicalizeHost(host);
-  return !canonicalized_host.empty();
-}
-
 }  // namespace
 
 namespace options2 {
 
-class ContentSettingsHandler::ExContentSettingsType {
- public:
-  explicit ExContentSettingsType(int value) : value_(value) {
-    DCHECK(value_ < EX_CONTENT_SETTINGS_NUM_TYPES);
-  }
-  explicit ExContentSettingsType(ContentSettingsType type) : value_(type) {}
-  explicit ExContentSettingsType(ExContentSettingsTypeEnum type)
-      : value_(type) {}
-
-  bool IsExtraContentSettingsType() const {
-    return value_ >= CONTENT_SETTINGS_NUM_TYPES;
-  }
-
-  operator int() const { return value_; }
-
-  ContentSettingsType ToContentSettingsType() const {
-    DCHECK(value_ < CONTENT_SETTINGS_NUM_TYPES);
-    return static_cast<ContentSettingsType>(value_);
-  }
-
- private:
-  int value_;
-};
-
-ContentSettingsHandler::CachedPepperFlashSettings::CachedPepperFlashSettings()
-    : default_permission(PP_FLASH_BROWSEROPERATIONS_PERMISSION_BLOCK),
-      initialized(false) {
-}
-
-ContentSettingsHandler::CachedPepperFlashSettings::~CachedPepperFlashSettings() {
-}
-
-struct ContentSettingsHandler::ExContentSettingsTypeNameEntry {
-  ExContentSettingsType type;
-  const char* name;
-};
-
-const ContentSettingsHandler::ExContentSettingsTypeNameEntry
-    ContentSettingsHandler::kExContentSettingsTypeGroupNames[] = {
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_COOKIES), "cookies"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_IMAGES), "images"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_JAVASCRIPT), "javascript"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_PLUGINS), "plugins"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_POPUPS), "popups"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_GEOLOCATION), "location"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_NOTIFICATIONS), "notifications"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_INTENTS), "intents"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE),
-   "auto-select-certificate"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_FULLSCREEN), "fullscreen"},
-  {ExContentSettingsType(CONTENT_SETTINGS_TYPE_MOUSELOCK), "mouselock"},
-  {ExContentSettingsType(EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC),
-   "pepper-flash-cameramic"},
-};
-
 ContentSettingsHandler::ContentSettingsHandler() {
 }
 
 ContentSettingsHandler::~ContentSettingsHandler() {
 }
 
 void ContentSettingsHandler::GetLocalizedValues(
     DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
@@ skipping 60 matching lines @@
     { "allowWebIntents", IDS_ALLOW_WEB_INTENTS },
     // Fullscreen filter.
     { "fullscreen_tab_label", IDS_FULLSCREEN_TAB_LABEL },
     { "fullscreen_header", IDS_FULLSCREEN_HEADER },
     // Mouse Lock filter.
     { "mouselock_tab_label", IDS_MOUSE_LOCK_TAB_LABEL },
     { "mouselock_header", IDS_MOUSE_LOCK_HEADER },
     { "mouselock_allow", IDS_MOUSE_LOCK_ALLOW_RADIO },
     { "mouselock_ask", IDS_MOUSE_LOCK_ASK_RADIO },
     { "mouselock_block", IDS_MOUSE_LOCK_BLOCK_RADIO },
-    // Pepper Flash camera and microphone filter.
-    { "pepperFlashCameramicTabLabel", IDS_PEPPER_FLASH_CAMERAMIC_TAB_LABEL },
-    // The header has to be named as <content_type_name>_header.
-    { "pepper-flash-cameramic_header", IDS_PEPPER_FLASH_CAMERAMIC_HEADER },
-    { "pepperFlashCameramicAsk", IDS_PEPPER_FLASH_CAMERAMIC_ASK_RADIO },
-    { "pepperFlashCameramicBlock", IDS_PEPPER_FLASH_CAMERAMIC_BLOCK_RADIO },
 #if defined(OS_CHROMEOS)
     // Protected Content filter
     { "protectedContentTabLabel", IDS_PROTECTED_CONTENT_TAB_LABEL },
     { "protectedContentInfo", IDS_PROTECTED_CONTENT_INFO },
     { "protectedContentEnable", IDS_PROTECTED_CONTENT_ENABLE},
 #endif  // defined(OS_CHROMEOS)
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterTitle(localized_strings, "contentSettingsPage",
@@ skipping 12 matching lines @@
   RegisterTitle(localized_strings, "popups",
                 IDS_POPUP_TAB_LABEL);
   RegisterTitle(localized_strings, "location",
                 IDS_GEOLOCATION_TAB_LABEL);
   RegisterTitle(localized_strings, "notifications",
                 IDS_NOTIFICATIONS_TAB_LABEL);
   RegisterTitle(localized_strings, "fullscreen",
                 IDS_FULLSCREEN_TAB_LABEL);
   RegisterTitle(localized_strings, "mouselock",
                 IDS_MOUSE_LOCK_TAB_LABEL);
-  RegisterTitle(localized_strings, "pepper-flash-cameramic",
-                IDS_PEPPER_FLASH_CAMERAMIC_TAB_LABEL);
 
   Profile* profile = Profile::FromWebUI(web_ui());
   localized_strings->SetBoolean(
       "enable_web_intents",
       web_intents::IsWebIntentsEnabledForProfile(profile));
   // TODO(marja): clean up the options UI after the decision on the session
   // restore changes has stabilized.
   localized_strings->SetBoolean(
       "enable_restore_session_state", false);
 }
@@ skipping 13 matching lines @@
       this, chrome::NOTIFICATION_DESKTOP_NOTIFICATION_SETTINGS_CHANGED,
       content::NotificationService::AllSources());
   Profile* profile = Profile::FromWebUI(web_ui());
   notification_registrar_.Add(
       this, chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
       content::Source<Profile>(profile));
 
   PrefService* prefs = profile->GetPrefs();
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(prefs::kGeolocationContentSettings, this);
-  pref_change_registrar_.Add(prefs::kPepperFlashSettingsEnabled, this);
-
-  flash_settings_manager_.reset(new PepperFlashSettingsManager(this, profile));
 }
 
 void ContentSettingsHandler::InitializePage() {
   UpdateHandlersEnabledRadios();
   UpdateAllExceptionsViewsFromModel();
-
-  flash_cameramic_settings_ = CachedPepperFlashSettings();
-  flash_settings_manager_->GetPermissionSettings(
-      PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC);
 }
 
 void ContentSettingsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       if (content::Source<Profile>(source).ptr()->IsOffTheRecord()) {
         web_ui()->CallJavascriptFunction(
@@ skipping 13 matching lines @@
       HostContentSettingsMap* map =
           content::Source<HostContentSettingsMap>(source).ptr();
       if (map != GetContentSettingsMap() &&
           map != GetOTRContentSettingsMap())
         break;
 
       const ContentSettingsDetails* settings_details =
           content::Details<const ContentSettingsDetails>(details).ptr();
 
       // TODO(estade): we pretend update_all() is always true.
-      if (settings_details->update_all_types()) {
+      if (settings_details->update_all_types())
         UpdateAllExceptionsViewsFromModel();
-      } else {
-        UpdateExceptionsViewFromModel(
-            ExContentSettingsType(settings_details->type()));
-      }
+      else
+        UpdateExceptionsViewFromModel(settings_details->type());
       break;
     }
 
     case chrome::NOTIFICATION_PREF_CHANGED: {
       const std::string& pref_name =
           *content::Details<std::string>(details).ptr();
-      if (pref_name == prefs::kGeolocationContentSettings) {
+      if (pref_name == prefs::kGeolocationContentSettings)
         UpdateGeolocationExceptionsView();
-      } else if (pref_name == prefs::kPepperFlashSettingsEnabled) {
-        if (!flash_cameramic_settings_.initialized) {
-          flash_settings_manager_->GetPermissionSettings(
-              PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC);
-        }
-      }
-
       break;
     }
 
     case chrome::NOTIFICATION_DESKTOP_NOTIFICATION_SETTINGS_CHANGED: {
       UpdateNotificationExceptionsView();
       break;
     }
 
     case chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED: {
       UpdateHandlersEnabledRadios();
       break;
     }
 
     default:
       OptionsPageUIHandler::Observe(type, source, details);
   }
 }
 
-void ContentSettingsHandler::OnGetPermissionSettingsCompleted(
-    uint32 /* request_id */,
-    bool success,
-    PP_Flash_BrowserOperations_Permission default_permission,
-    const ppapi::FlashSiteSettings& sites) {
-  if (success && !flash_cameramic_settings_.initialized) {
-    flash_cameramic_settings_.initialized = true;
-    flash_cameramic_settings_.default_permission = default_permission;
-    for (ppapi::FlashSiteSettings::const_iterator iter = sites.begin();
-         iter != sites.end(); ++iter) {
-      if (IsValidHost(iter->site))
-        flash_cameramic_settings_.sites[iter->site] = iter->permission;
-    }
-    UpdateExceptionsViewFromModel(
-        ExContentSettingsType(EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC));
-
-    web_ui()->CallJavascriptFunction(
-        "ContentSettings.enablePepperFlashCameraMicSettings");
-  }
-}
-
 void ContentSettingsHandler::UpdateSettingDefaultFromModel(
-    const ExContentSettingsType& type) {
+    ContentSettingsType type) {
   DictionaryValue filter_settings;
   std::string provider_id;
+  filter_settings.SetString(ContentSettingsTypeToGroupName(type) + ".value",
+                            GetSettingDefaultFromModel(type, &provider_id));
   filter_settings.SetString(
-      ExContentSettingsTypeToGroupName(type) + ".value",
-      GetSettingDefaultFromModel(type, &provider_id));
-  filter_settings.SetString(
-      ExContentSettingsTypeToGroupName(type) + ".managedBy", provider_id);
+      ContentSettingsTypeToGroupName(type) + ".managedBy",
+      provider_id);
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.setContentFilterSettingsValue", filter_settings);
   web_ui()->CallJavascriptFunction(
       "BrowserOptions.setContentFilterSettingsValue", filter_settings);
 }
 
 std::string ContentSettingsHandler::GetSettingDefaultFromModel(
-    const ExContentSettingsType& type, std::string* provider_id) {
+    ContentSettingsType type, std::string* provider_id) {
   Profile* profile = Profile::FromWebUI(web_ui());
   ContentSetting default_setting;
   if (type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     default_setting =
         DesktopNotificationServiceFactory::GetForProfile(profile)->
             GetDefaultContentSetting(provider_id);
-  } else if (type == EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC) {
-    default_setting = FlashPermissionToContentSetting(
-        flash_cameramic_settings_.default_permission);
-    *provider_id = kDefaultProviderID;
   } else {
     default_setting =
         profile->GetHostContentSettingsMap()->
-            GetDefaultContentSetting(type.ToContentSettingsType(), provider_id);
+            GetDefaultContentSetting(type, provider_id);
   }
 
   return ContentSettingToString(default_setting);
 }
 
 void ContentSettingsHandler::UpdateHandlersEnabledRadios() {
   base::FundamentalValue handlers_enabled(
       GetProtocolHandlerRegistry()->enabled());
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.updateHandlersEnabledRadios",
       handlers_enabled);
 }
 
 void ContentSettingsHandler::UpdateAllExceptionsViewsFromModel() {
   for (int type = CONTENT_SETTINGS_TYPE_DEFAULT + 1;
-       type < EX_CONTENT_SETTINGS_NUM_TYPES; ++type) {
+       type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
     // The content settings type CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE
     // is supposed to be set by policy only. Hence there is no user facing UI
     // for this content type and we skip it here.
     if (type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE)
       continue;
-    UpdateExceptionsViewFromModel(ExContentSettingsType(type));
+    UpdateExceptionsViewFromModel(static_cast<ContentSettingsType>(type));
   }
 }
 
 void ContentSettingsHandler::UpdateAllOTRExceptionsViewsFromModel() {
   for (int type = CONTENT_SETTINGS_TYPE_DEFAULT + 1;
-       type < EX_CONTENT_SETTINGS_NUM_TYPES; ++type) {
-    UpdateOTRExceptionsViewFromModel(ExContentSettingsType(type));
+       type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
+    UpdateOTRExceptionsViewFromModel(static_cast<ContentSettingsType>(type));
   }
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromModel(
-    const ExContentSettingsType& type) {
+    ContentSettingsType type) {
   // Don't update intents settings at this point.
   // Turn on when enable_web_intents_tag is enabled.
   if (type == CONTENT_SETTINGS_TYPE_INTENTS)
     return;
 
   switch (type) {
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
       UpdateGeolocationExceptionsView();
       break;
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       UpdateNotificationExceptionsView();
       break;
-    case EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC:
-      UpdateFlashCameraMicExceptionsView();
-      break;
     default:
-      UpdateExceptionsViewFromHostContentSettingsMap(
-          type.ToContentSettingsType());
+      UpdateExceptionsViewFromHostContentSettingsMap(type);
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateOTRExceptionsViewFromModel(
-    const ExContentSettingsType& type) {
+    ContentSettingsType type) {
   switch (type) {
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
     case CONTENT_SETTINGS_TYPE_INTENTS:
     case CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE:
-    case EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC:
       break;
     default:
-      UpdateExceptionsViewFromOTRHostContentSettingsMap(
-          type.ToContentSettingsType());
+      UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateGeolocationExceptionsView() {
   Profile* profile = Profile::FromWebUI(web_ui());
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
 
   ContentSettingsForOneType all_settings;
   map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_GEOLOCATION,
       std::string(),
       &all_settings);
 
   // Group geolocation settings by primary_pattern.
   AllPatternsSettings all_patterns_settings;
   for (ContentSettingsForOneType::iterator i =
            all_settings.begin();
        i != all_settings.end();
        ++i) {
     // Don't add default settings.
     if (i->primary_pattern == ContentSettingsPattern::Wildcard() &&
         i->secondary_pattern == ContentSettingsPattern::Wildcard() &&
-        i->source != kPreferencesSource) {
+        i->source != "preferences") {
       continue;
     }
     all_patterns_settings[i->primary_pattern][i->secondary_pattern] =
         i->setting;
   }
 
   ListValue exceptions;
   AddExceptionsGrantedByHostedApps(
       profile, ExtensionAPIPermission::kGeolocation, &exceptions);
 
@@ skipping 26 matching lines @@
     }
   }
 
   StringValue type_string(
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_GEOLOCATION));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
                                    type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
-  UpdateSettingDefaultFromModel(
-      ExContentSettingsType(CONTENT_SETTINGS_TYPE_GEOLOCATION));
+  UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_GEOLOCATION);
 }
 
 void ContentSettingsHandler::UpdateNotificationExceptionsView() {
   Profile* profile = Profile::FromWebUI(web_ui());
   DesktopNotificationService* service =
       DesktopNotificationServiceFactory::GetForProfile(profile);
 
   ContentSettingsForOneType settings;
   service->GetNotificationsSettings(&settings);
 
   ListValue exceptions;
   AddExceptionsGrantedByHostedApps(
       profile, ExtensionAPIPermission::kNotification, &exceptions);
 
   for (ContentSettingsForOneType::const_iterator i =
            settings.begin();
        i != settings.end();
        ++i) {
     // Don't add default settings.
     if (i->primary_pattern == ContentSettingsPattern::Wildcard() &&
         i->secondary_pattern == ContentSettingsPattern::Wildcard() &&
-        i->source != kPreferencesSource) {
+        i->source != "preferences") {
       continue;
     }
 
     exceptions.Append(
         GetNotificationExceptionForPage(i->primary_pattern, i->setting,
                                         i->source));
   }
 
   StringValue type_string(
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
                                    type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
-  UpdateSettingDefaultFromModel(
-      ExContentSettingsType(CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
-}
-
-void ContentSettingsHandler::UpdateFlashCameraMicExceptionsView() {
-  ListValue exceptions;
-  for (CachedPepperFlashSettings::SiteMap::iterator iter =
-           flash_cameramic_settings_.sites.begin();
-       iter != flash_cameramic_settings_.sites.end(); ++iter) {
-    DictionaryValue* exception = new DictionaryValue();
-    exception->SetString(kDisplayPattern, iter->first);
-    exception->SetString(
-        kSetting,
-        ContentSettingToString(FlashPermissionToContentSetting(iter->second)));
-    exception->SetString(kSource, kPreferencesSource);
-    exceptions.Append(exception);
-  }
-
-  StringValue type_string(ExContentSettingsTypeToGroupName(
-      ExContentSettingsType(EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC)));
-  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
-                                   type_string, exceptions);
-
-  UpdateSettingDefaultFromModel(
-      ExContentSettingsType(EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC));
+  UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   ContentSettingsForOneType entries;
   GetContentSettingsMap()->GetSettingsForOneType(type, "", &entries);
 
   ListValue exceptions;
   for (size_t i = 0; i < entries.size(); ++i) {
     // Skip default settings from extensions and policy, and the default content
@@ skipping 25 matching lines @@
 
   UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
 
   // TODO(koz): The default for fullscreen is always 'ask'.
   // http://crbug.com/104683
   if (type == CONTENT_SETTINGS_TYPE_FULLSCREEN)
     return;
 
   // The default may also have changed (we won't get a separate notification).
   // If it hasn't changed, this call will be harmless.
-  UpdateSettingDefaultFromModel(ExContentSettingsType(type));
+  UpdateSettingDefaultFromModel(type);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromOTRHostContentSettingsMap(
     ContentSettingsType type) {
   const HostContentSettingsMap* otr_settings_map = GetOTRContentSettingsMap();
   if (!otr_settings_map)
     return;
 
   ContentSettingsForOneType otr_entries;
   otr_settings_map->GetSettingsForOneType(type, "", &otr_entries);
@@ skipping 75 matching lines @@
 void ContentSettingsHandler::SetContentFilter(const ListValue* args) {
   DCHECK_EQ(2U, args->GetSize());
   std::string group, setting;
   if (!(args->GetString(0, &group) &&
         args->GetString(1, &setting))) {
     NOTREACHED();
     return;
   }
 
   ContentSetting default_setting = ContentSettingFromString(setting);
-  ExContentSettingsType content_type =
-      ExContentSettingsTypeFromGroupName(group);
+  ContentSettingsType content_type = ContentSettingsTypeFromGroupName(group);
   Profile* profile = Profile::FromWebUI(web_ui());
 
 #if defined(OS_CHROMEOS)
   // ChromeOS special case : in Guest mode settings are opened in Incognito
   // mode, so we need original profile to actually modify settings.
   if (chromeos::UserManager::Get()->IsLoggedInAsGuest())
     profile = profile->GetOriginalProfile();
 #endif
 
   if (content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     DesktopNotificationServiceFactory::GetForProfile(profile)->
         SetDefaultContentSetting(default_setting);
-  } else if (content_type == EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC) {
-    flash_cameramic_settings_.default_permission =
-        FlashPermissionFromContentSetting(default_setting);
-    flash_settings_manager_->SetDefaultPermission(
-        PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC,
-        flash_cameramic_settings_.default_permission, false);
   } else {
     HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
-    ContentSettingsType converted_type = content_type.ToContentSettingsType();
-    ApplyWhitelist(converted_type, default_setting);
-    map->SetDefaultContentSetting(converted_type, default_setting);
+    ApplyWhitelist(content_type, default_setting);
+    map->SetDefaultContentSetting(content_type, default_setting);
   }
   switch (content_type) {
     case CONTENT_SETTINGS_TYPE_COOKIES:
       content::RecordAction(
           UserMetricsAction("Options_DefaultCookieSettingChanged"));
       break;
     case CONTENT_SETTINGS_TYPE_IMAGES:
       content::RecordAction(
           UserMetricsAction("Options_DefaultImagesSettingChanged"));
       break;
@@ skipping 18 matching lines @@
           UserMetricsAction("Options_DefaultGeolocationSettingChanged"));
       break;
     case CONTENT_SETTINGS_TYPE_INTENTS:
       content::RecordAction(
           UserMetricsAction("Options_DefaultHandlersSettingChanged"));
       break;
     case CONTENT_SETTINGS_TYPE_MOUSELOCK:
       content::RecordAction(
           UserMetricsAction("Options_DefaultMouseLockSettingChanged"));
       break;
-    case EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC:
-      content::RecordAction(
-          UserMetricsAction("Options_DefaultFlashCameraMicSettingChanged"));
-      break;
     default:
       break;
   }
 }
 
 void ContentSettingsHandler::RemoveException(const ListValue* args) {
   size_t arg_i = 0;
   std::string type_string;
   CHECK(args->GetString(arg_i++, &type_string));
 
   Profile* profile = Profile::FromWebUI(web_ui());
-  ExContentSettingsType type = ExContentSettingsTypeFromGroupName(
-      type_string);
+  ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
     std::string origin;
     std::string embedding_origin;
     bool rv = args->GetString(arg_i++, &origin);
     DCHECK(rv);
     rv = args->GetString(arg_i++, &embedding_origin);
     DCHECK(rv);
 
     profile->GetHostContentSettingsMap()->
         SetContentSetting(ContentSettingsPattern::FromString(origin),
@@ skipping 16 matching lines @@
         ClearSetting(ContentSettingsPattern::FromString(origin));
   } else {
     std::string mode;
     bool rv = args->GetString(arg_i++, &mode);
     DCHECK(rv);
 
     std::string pattern;
     rv = args->GetString(arg_i++, &pattern);
     DCHECK(rv);
 
-    if (type == EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC) {
-      DCHECK_EQ(mode, "normal");
-
-      CachedPepperFlashSettings::SiteMap::iterator iter =
-          flash_cameramic_settings_.sites.find(pattern);
-      if (iter != flash_cameramic_settings_.sites.end()) {
-        flash_cameramic_settings_.sites.erase(iter);
-        ppapi::FlashSiteSettings site_settings(1,
-            ppapi::FlashSiteSetting(
-                pattern, PP_FLASH_BROWSEROPERATIONS_PERMISSION_DEFAULT));
-        flash_settings_manager_->SetSitePermission(
-            PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC,
-            site_settings);
-      } else {
-        NOTREACHED();
-      }
-      UpdateFlashCameraMicExceptionsView();
-    } else {
-      HostContentSettingsMap* settings_map =
-          mode == "normal" ? GetContentSettingsMap() :
-                             GetOTRContentSettingsMap();
-      // The settings map could be null if the mode was OTR but the OTR profile
-      // got destroyed before we received this message.
-      if (settings_map) {
-        settings_map->SetContentSetting(
-            ContentSettingsPattern::FromString(pattern),
-            ContentSettingsPattern::Wildcard(),
-            type.ToContentSettingsType(),
-            "",
-            CONTENT_SETTING_DEFAULT);
-      }
+    HostContentSettingsMap* settings_map =
+        mode == "normal" ? GetContentSettingsMap() :
+                           GetOTRContentSettingsMap();
+    // The settings map could be null if the mode was OTR but the OTR profile
+    // got destroyed before we received this message.
+    if (settings_map) {
+      settings_map->SetContentSetting(
+          ContentSettingsPattern::FromString(pattern),
+          ContentSettingsPattern::Wildcard(),
+          ContentSettingsTypeFromGroupName(type_string),
+          "",
+          CONTENT_SETTING_DEFAULT);
     }
   }
 }
 
 void ContentSettingsHandler::SetException(const ListValue* args) {
   size_t arg_i = 0;
   std::string type_string;
   CHECK(args->GetString(arg_i++, &type_string));
   std::string mode;
   CHECK(args->GetString(arg_i++, &mode));
   std::string pattern;
   CHECK(args->GetString(arg_i++, &pattern));
   std::string setting;
   CHECK(args->GetString(arg_i++, &setting));
 
-  ExContentSettingsType type = ExContentSettingsTypeFromGroupName(type_string);
+  ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
       type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     NOTREACHED();
-  } else if (type == EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC) {
-    DCHECK(IsValidHost(pattern));
+    return;
+  }
 
-    if (flash_cameramic_settings_.sites.find(pattern) ==
-        flash_cameramic_settings_.sites.end()) {
-      pattern = CanonicalizeHost(pattern);
-    }
-    PP_Flash_BrowserOperations_Permission permission =
-        FlashPermissionFromContentSetting(ContentSettingFromString(setting));
-    flash_cameramic_settings_.sites[pattern] = permission;
-    ppapi::FlashSiteSettings
-        site_settings(1, ppapi::FlashSiteSetting(pattern, permission));
-    flash_settings_manager_->SetSitePermission(
-        PP_FLASH_BROWSEROPERATIONS_SETTINGTYPE_CAMERAMIC,
-        site_settings);
-    UpdateFlashCameraMicExceptionsView();
-  } else {
-    HostContentSettingsMap* settings_map =
-        mode == "normal" ? GetContentSettingsMap() :
-                           GetOTRContentSettingsMap();
+  HostContentSettingsMap* settings_map =
+      mode == "normal" ? GetContentSettingsMap() :
+                         GetOTRContentSettingsMap();
 
-    // The settings map could be null if the mode was OTR but the OTR profile
-    // got destroyed before we received this message.
-    if (!settings_map)
-      return;
-    settings_map->SetContentSetting(ContentSettingsPattern::FromString(pattern),
-                                    ContentSettingsPattern::Wildcard(),
-                                    type.ToContentSettingsType(),
-                                    "",
-                                    ContentSettingFromString(setting));
-  }
+  // The settings map could be null if the mode was OTR but the OTR profile
+  // got destroyed before we received this message.
+  if (!settings_map)
+    return;
+  settings_map->SetContentSetting(ContentSettingsPattern::FromString(pattern),
+                                  ContentSettingsPattern::Wildcard(),
+                                  type,
+                                  "",
+                                  ContentSettingFromString(setting));
 }
 
 void ContentSettingsHandler::CheckExceptionPatternValidity(
     const ListValue* args) {
   size_t arg_i = 0;
-  std::string type_string;
-  CHECK(args->GetString(arg_i++, &type_string));
+  Value* type;
+  CHECK(args->Get(arg_i++, &type));
   std::string mode_string;
   CHECK(args->GetString(arg_i++, &mode_string));
   std::string pattern_string;
   CHECK(args->GetString(arg_i++, &pattern_string));
 
-  ExContentSettingsType type = ExContentSettingsTypeFromGroupName(type_string);
-  bool is_valid = false;
-  if (type == EX_CONTENT_SETTINGS_TYPE_PEPPER_FLASH_CAMERAMIC) {
-    is_valid = IsValidHost(pattern_string);
-  } else {
-    ContentSettingsPattern pattern =
-        ContentSettingsPattern::FromString(pattern_string);
-    is_valid = pattern.IsValid();
-  }
+  ContentSettingsPattern pattern =
+      ContentSettingsPattern::FromString(pattern_string);
 
-  scoped_ptr<Value> type_value(Value::CreateStringValue(type_string));
   scoped_ptr<Value> mode_value(Value::CreateStringValue(mode_string));
   scoped_ptr<Value> pattern_value(Value::CreateStringValue(pattern_string));
-  scoped_ptr<Value> valid_value(Value::CreateBooleanValue(is_valid));
+  scoped_ptr<Value> valid_value(Value::CreateBooleanValue(pattern.IsValid()));
 
   web_ui()->CallJavascriptFunction(
       "ContentSettings.patternValidityCheckComplete",
-      *type_value.get(),
+      *type,
       *mode_value.get(),
       *pattern_value.get(),
       *valid_value.get());
 }
 
 // static
 std::string ContentSettingsHandler::ContentSettingsTypeToGroupName(
     ContentSettingsType type) {
-  return ExContentSettingsTypeToGroupName(ExContentSettingsType(type));
+  for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
+    if (type == kContentSettingsTypeGroupNames[i].type)
+      return kContentSettingsTypeGroupNames[i].name;
+  }
+
+  NOTREACHED();
+  return std::string();
 }
 
 HostContentSettingsMap* ContentSettingsHandler::GetContentSettingsMap() {
   return Profile::FromWebUI(web_ui())->GetHostContentSettingsMap();
 }
 
 ProtocolHandlerRegistry* ContentSettingsHandler::GetProtocolHandlerRegistry() {
   return Profile::FromWebUI(web_ui())->GetProtocolHandlerRegistry();
 }
 
 HostContentSettingsMap*
     ContentSettingsHandler::GetOTRContentSettingsMap() {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (profile->HasOffTheRecordProfile())
     return profile->GetOffTheRecordProfile()->GetHostContentSettingsMap();
   return NULL;
 }
 
-// static
-ContentSettingsHandler::ExContentSettingsType
-    ContentSettingsHandler::ExContentSettingsTypeFromGroupName(
-        const std::string& name) {
-  COMPILE_ASSERT(arraysize(kExContentSettingsTypeGroupNames) ==
-                     EX_CONTENT_SETTINGS_NUM_TYPES,
-                 MISSING_CONTENT_SETTINGS_TYPE);
-
-  for (size_t i = 0; i < arraysize(kExContentSettingsTypeGroupNames); ++i) {
-    if (name == kExContentSettingsTypeGroupNames[i].name)
-      return kExContentSettingsTypeGroupNames[i].type;
-  }
-
-  NOTREACHED() << name << " is not a recognized content settings type.";
-  return ExContentSettingsType(CONTENT_SETTINGS_TYPE_DEFAULT);
-}
-
-// static
-std::string ContentSettingsHandler::ExContentSettingsTypeToGroupName(
-    const ExContentSettingsType& type) {
-  for (size_t i = 0; i < arraysize(kExContentSettingsTypeGroupNames); ++i) {
-    if (type == kExContentSettingsTypeGroupNames[i].type)
-      return kExContentSettingsTypeGroupNames[i].name;
-  }
-
-  NOTREACHED();
-  return std::string();
-}
-
 }  // namespace options2