[Re-landing] Migrate external protocol prefs from local state to profiles

chrome/browser/external_protocol/external_protocol_handler.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/external_protocol/external_protocol_handler.h"
 
 #include <stddef.h>
 
 #include <set>
 
@@ skipping 34 matching lines @@
     const std::string& protocol,
     ExternalProtocolHandler::Delegate* delegate) {
   if (delegate)
     return delegate->CreateShellWorker(callback, protocol);
 
   return new shell_integration::DefaultProtocolClientWorker(callback, protocol);
 }
 
 ExternalProtocolHandler::BlockState GetBlockStateWithDelegate(
     const std::string& scheme,
-    ExternalProtocolHandler::Delegate* delegate) {
+    ExternalProtocolHandler::Delegate* delegate,
+    Profile* profile) {
   if (!delegate)
-    return ExternalProtocolHandler::GetBlockState(scheme);
+    return ExternalProtocolHandler::GetBlockState(scheme, profile);
 
-  return delegate->GetBlockState(scheme);
+  return delegate->GetBlockState(scheme, profile);
 }
 
 void RunExternalProtocolDialogWithDelegate(
     const GURL& url,
     int render_process_host_id,
     int routing_id,
     ui::PageTransition page_transition,
     bool has_user_gesture,
     ExternalProtocolHandler::Delegate* delegate) {
   if (!delegate) {
@@ skipping 58 matching lines @@
   }
 
   LaunchUrlWithoutSecurityCheckWithDelegate(escaped_url, render_process_host_id,
                                             render_view_routing_id, delegate);
 }
 
 }  // namespace
 
 // static
 ExternalProtocolHandler::BlockState ExternalProtocolHandler::GetBlockState(
-    const std::string& scheme) {
+    const std::string& scheme,
+    Profile* profile) {
   // If we are being carpet bombed, block the request.
   if (!g_accept_requests)
     return BLOCK;
 
   if (scheme.length() == 1) {
     // We have a URL that looks something like:
     //   C:/WINDOWS/system32/notepad.exe
     // ShellExecuting this URL will cause the specified program to be executed.
     return BLOCK;
   }
 
-  // Check the stored prefs.
-  // TODO(pkasting): This kind of thing should go in the preferences on the
-  // profile, not in the local state. http://crbug.com/457254
-  PrefService* pref = g_browser_process->local_state();
-  if (pref) {  // May be NULL during testing.
-    DictionaryPrefUpdate update_excluded_schemas(pref, prefs::kExcludedSchemes);
+  // Check if there are any prefs in the local state. If there are, wipe them,
+  // and migrate the prefs to the profile.
+  // TODO(ramyasharma) remove the migration in M61.
+  PrefService* local_prefs = g_browser_process->local_state();
+  PrefService* profile_prefs = profile->GetPrefs();
+  if (local_prefs && profile_prefs) {  // May be NULL during testing.
+    DictionaryPrefUpdate local_state_schemas(local_prefs,
+                                             prefs::kExcludedSchemes);
+    DictionaryPrefUpdate update_excluded_schemas_profile(
+        profile_prefs, prefs::kExcludedSchemes);
+    if (update_excluded_schemas_profile->empty()) {
+      // Copy local state to profile state.
+      for (base::DictionaryValue::Iterator it(*local_state_schemas);
+           !it.IsAtEnd(); it.Advance()) {
+        bool is_blocked;
+        // Discard local state if set to blocked, to reset all users
+        // stuck in 'Do Nothing' + 'Do Not Open' state back to the default
+        // prompt state.
+        if (it.value().GetAsBoolean(&is_blocked) && !is_blocked)
+          update_excluded_schemas_profile->SetBoolean(it.key(), is_blocked);
+      }
+      // TODO(ramyasharma): Clear only if required.
+      local_prefs->ClearPref(prefs::kExcludedSchemes);
+    }
 
-    // Warm up the dictionary if needed.
-    PrepopulateDictionary(update_excluded_schemas.Get());
+    // Prepopulate the default states each time.
+    PrepopulateDictionary(update_excluded_schemas_profile.Get());
 
     bool should_block;
-    if (update_excluded_schemas->GetBoolean(scheme, &should_block))
+    if (update_excluded_schemas_profile->GetBoolean(scheme, &should_block))
       return should_block ? BLOCK : DONT_BLOCK;
   }
 
   return UNKNOWN;
 }
 
 // static
 void ExternalProtocolHandler::SetBlockState(const std::string& scheme,
-                                            BlockState state) {
+                                            BlockState state,
+                                            Profile* profile) {
   // Set in the stored prefs.
-  // TODO(pkasting): This kind of thing should go in the preferences on the
-  // profile, not in the local state. http://crbug.com/457254
-  PrefService* pref = g_browser_process->local_state();
-  if (pref) {  // May be NULL during testing.
-    DictionaryPrefUpdate update_excluded_schemas(pref, prefs::kExcludedSchemes);
-
-    if (state == UNKNOWN) {
-      update_excluded_schemas->Remove(scheme, NULL);
-    } else {
-      update_excluded_schemas->SetBoolean(scheme, (state == BLOCK));
+  PrefService* profile_prefs = profile->GetPrefs();
+  if (profile_prefs) {  // May be NULL during testing.
+    DictionaryPrefUpdate update_excluded_schemas_profile(
+        profile_prefs, prefs::kExcludedSchemes);
+    if (!update_excluded_schemas_profile->empty()) {
+      if (state == UNKNOWN)
+        update_excluded_schemas_profile->Remove(scheme, nullptr);
+      else
+        update_excluded_schemas_profile->SetBoolean(scheme, (state == BLOCK));
     }
   }
 }
 
 // static
 void ExternalProtocolHandler::LaunchUrlWithDelegate(
     const GURL& url,
     int render_process_host_id,
     int render_view_routing_id,
     ui::PageTransition page_transition,
     bool has_user_gesture,
     Delegate* delegate) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   // Escape the input scheme to be sure that the command does not
   // have parameters unexpected by the external program.
   std::string escaped_url_string = net::EscapeExternalHandlerValue(url.spec());
   GURL escaped_url(escaped_url_string);
+
+  content::WebContents* web_contents = tab_util::GetWebContentsByID(
+      render_process_host_id, render_view_routing_id);
+  Profile* profile = nullptr;
+  if (web_contents)  // Maybe NULL during testing.
+    profile = Profile::FromBrowserContext(web_contents->GetBrowserContext());
   BlockState block_state =
-      GetBlockStateWithDelegate(escaped_url.scheme(), delegate);
+      GetBlockStateWithDelegate(escaped_url.scheme(), delegate, profile);
   if (block_state == BLOCK) {
     if (delegate)
       delegate->BlockRequest();
     return;
   }
 
   g_accept_requests = false;
 
   // The worker creates tasks with references to itself and puts them into
   // message loops.
@@ skipping 24 matching lines @@
 
 // static
 void ExternalProtocolHandler::PermitLaunchUrl() {
   DCHECK(base::MessageLoopForUI::IsCurrent());
   g_accept_requests = true;
 }
 
 // static
 void ExternalProtocolHandler::PrepopulateDictionary(
     base::DictionaryValue* win_pref) {
-  static bool is_warm = false;
-  if (is_warm)
-    return;
-  is_warm = true;
-
   static const char* const denied_schemes[] = {
     "afp",
     "data",
     "disk",
     "disks",
     // ShellExecuting file:///C:/WINDOWS/system32/notepad.exe will simply
     // execute the file specified!  Hopefully we won't see any "file" schemes
     // because we think of file:// URLs as handled URLs, but better to be safe
     // than to let an attacker format the user's hard drive.
     "file",
@@ skipping 33 matching lines @@
 // static
 void ExternalProtocolHandler::RecordMetrics(bool selected) {
   UMA_HISTOGRAM_BOOLEAN("BrowserDialogs.ExternalProtocol.RememberCheckbox",
                         selected);
 }
 
 // static
 void ExternalProtocolHandler::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kExcludedSchemes);
 }