Move supports-high-dpi flag into registry.

chrome/browser/about_flags.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/about_flags.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <set>
@@ skipping 30 matching lines @@
 
 #if defined(USE_ASH)
 #include "ash/ash_switches.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/chromeos_switches.h"
 #include "third_party/cros_system_api/switches/chrome_switches.h"
 #endif
 
+#if defined(OS_WIN)
+#include "base/win/registry.h"
+#endif
+
 #if defined(ENABLE_APP_LIST)
 #include "ui/app_list/app_list_switches.h"
 #endif
 
 using base::UserMetricsAction;
 
 namespace about_flags {
 
 // Macros to simplify specifying the type.
 #define SINGLE_VALUE_TYPE_AND_VALUE(command_line_switch, switch_value) \
     Experiment::SINGLE_VALUE, \
     command_line_switch, switch_value, NULL, NULL, NULL, 0
 #define SINGLE_VALUE_TYPE(command_line_switch) \
     SINGLE_VALUE_TYPE_AND_VALUE(command_line_switch, "")
 #define ENABLE_DISABLE_VALUE_TYPE_AND_VALUE(enable_switch, enable_value, \
                                             disable_switch, disable_value) \
     Experiment::ENABLE_DISABLE_VALUE, enable_switch, enable_value, \
     disable_switch, disable_value, NULL, 3
 #define ENABLE_DISABLE_VALUE_TYPE(enable_switch, disable_switch) \
     ENABLE_DISABLE_VALUE_TYPE_AND_VALUE(enable_switch, "", disable_switch, "")
 #define MULTI_VALUE_TYPE(choices) \
     Experiment::MULTI_VALUE, NULL, NULL, NULL, NULL, choices, arraysize(choices)
 
 namespace {
+#if defined(OS_WIN)
+const wchar_t kRegistryBasePath[] = L"SOFTWARE\\Google\\Chrome";
+const wchar_t kRegistryProfilePath[] = L"SOFTWARE\\Google\\Chrome\\Profile";
+const wchar_t kRegistryProfileSubkey[] = L"Profile";
+
+std::wstring ConvertToWString(const std::string& s) {

[sky, 2014/02/11 14:57:00]

There is a bunch of code for reading/writing to the registry in
base/win/registry.

[girard, 2014/02/11 18:51:48]

I'm using those functions below. Those functions (base::win::RegKey) use
wstring's, so this function helps with conversions.

+  std::wstring result;
+  result.assign(s.begin(),s.end());
+  return result;
+}
+
+bool FlagIsStoredInRegistry(const std::string& flagname) {
+  return strncmp(flagname.c_str(),switches::kHighDPISupport,
+      strlen(switches::kHighDPISupport))==0;
+}
+
+DWORD ReadRegistryValue(HKEY root,
+    const wchar_t* base_key, const wchar_t* sub_key,
+    const std::string& value_name, DWORD default_value) {
+  base::win::RegKey regKey(HKEY_CURRENT_USER,
+                               base_key,
+                               KEY_CREATE_SUB_KEY);
+  if (regKey.Valid() &&
+      regKey.OpenKey(sub_key, KEY_QUERY_VALUE) == ERROR_SUCCESS) {
+    DWORD value;
+    if (regKey.Valid() &&
+        regKey.ReadValueDW(ConvertToWString(value_name).c_str(),&value) ==
+        ERROR_SUCCESS) {
+      return value;
+    }
+  }
+  return default_value;
+}
+
+// WriteRegistryValue
+bool WriteRegistryValue(HKEY root,
+    const wchar_t* base_key, const wchar_t* sub_key,
+    const std::string& value_name, const char* value_string) {
+  DWORD value = atoi(value_string);
+  base::win::RegKey regKey(root,
+                               base_key,
+                               KEY_CREATE_SUB_KEY);
+  return regKey.Valid() &&
+      (regKey.CreateKey(sub_key, KEY_SET_VALUE) == ERROR_SUCCESS) &&
+      (regKey.WriteValue(ConvertToWString(value_name).c_str(),value) ==
+      ERROR_SUCCESS);
+}
+
+bool DeleteRegistryValue(
+     HKEY root, const wchar_t* subkey_name, const std::string& value_name) {
+  base::win::RegKey regKey(HKEY_CURRENT_USER,
+                           subkey_name,
+                           KEY_ALL_ACCESS);
+  return regKey.Valid() &&
+      regKey.DeleteValue(ConvertToWString(value_name).c_str()) == ERROR_SUCCESS;
+}
+
+#endif
 
 const unsigned kOsAll = kOsMac | kOsWin | kOsLinux | kOsCrOS | kOsAndroid;
 const unsigned kOsDesktop = kOsMac | kOsWin | kOsLinux | kOsCrOS;
 
 // Adds a |StringValue| to |list| for each platform where |bitmask| indicates
 // whether the experiment is available on that platform.
 void AddOsStrings(unsigned bitmask, base::ListValue* list) {
   struct {
     unsigned bit;
     const char* const name;
@@ skipping 2076 matching lines @@
     base::DictionaryValue* value = new base::DictionaryValue;
     const std::string name = experiment.NameForChoice(i);
     value->SetString("internal_name", name);
     value->SetString("description", experiment.DescriptionForChoice(i));
     value->SetBoolean("selected", enabled_experiments.count(name) > 0);
     result->Append(value);
   }
   return result;
 }
 
+base::Value* CreateChoiceDataFromRegistry(
+    const Experiment& experiment) {
+  DCHECK(experiment.type == Experiment::MULTI_VALUE ||
+         experiment.type == Experiment::ENABLE_DISABLE_VALUE);
+
+  DWORD registry_value = ReadRegistryValue(

[girard, 2014/02/11 20:29:00]

Self-review: This logic depends on other code that is #if defined(OS_WINDOWS).
I'll fix this.

+      HKEY_CURRENT_USER,kRegistryBasePath,
+      kRegistryProfileSubkey,experiment.internal_name,FALSE);
+  base::ListValue* result = new base::ListValue;
+  for (int i = 0; i < experiment.num_choices; ++i) {
+    base::DictionaryValue* value = new base::DictionaryValue;
+    const std::string name = experiment.NameForChoice(i);
+    value->SetString("internal_name", name);
+    value->SetString("description", experiment.DescriptionForChoice(i));
+    value->SetBoolean("selected", i == static_cast<int>(registry_value));
+    result->Append(value);
+  }
+  return result;
+}
+
 }  // namespace
 
 std::string Experiment::NameForChoice(int index) const {
   DCHECK(type == Experiment::MULTI_VALUE ||
          type == Experiment::ENABLE_DISABLE_VALUE);
   DCHECK_LT(index, num_choices);
   return std::string(internal_name) + testing::kMultiSeparator +
          base::IntToString(index);
 }
 
@@ skipping 64 matching lines @@
     data->Set("supported_platforms", supported_platforms);
 
     switch (experiment.type) {
       case Experiment::SINGLE_VALUE:
         data->SetBoolean(
             "enabled",
             enabled_experiments.count(experiment.internal_name) > 0);
         break;
       case Experiment::MULTI_VALUE:
       case Experiment::ENABLE_DISABLE_VALUE:
-        data->Set("choices", CreateChoiceData(experiment, enabled_experiments));
+        if (FlagIsStoredInRegistry(experiment.internal_name)) {
+          data->Set("choices", CreateChoiceDataFromRegistry(experiment));
+        } else {
+          data->Set("choices",
+              CreateChoiceData(experiment, enabled_experiments));
+        }
         break;
       default:
         NOTREACHED();
     }
 
     bool supported = (experiment.supported_platforms & current_platform) != 0;
 #if defined(OS_CHROMEOS)
     if (access == kOwnerAccessToFlags &&
         (experiment.supported_platforms & kOsCrOSOwnerOnly) != 0) {
       supported = true;
@@ skipping 156 matching lines @@
     DCHECK_NE(at_index, 0u);
     const std::string experiment_name = internal_name.substr(0, at_index);
     SetExperimentEnabled(flags_storage, experiment_name, false);
 
     // And enable the new choice, if it is not the default first choice.
     if (internal_name != experiment_name + "@0") {
       std::set<std::string> enabled_experiments;
       GetSanitizedEnabledFlags(flags_storage, &enabled_experiments);
       needs_restart_ |= enabled_experiments.insert(internal_name).second;
       flags_storage->SetFlags(enabled_experiments);
+#if defined(OS_WIN)
+      if (FlagIsStoredInRegistry(experiment_name)) {
+        WriteRegistryValue(HKEY_CURRENT_USER,kRegistryBasePath,
+            kRegistryProfileSubkey,experiment_name.c_str(),
+            internal_name.substr(at_index+1,1).c_str());
+      }
+#endif
     }
     return;
   }
 
   std::set<std::string> enabled_experiments;
   GetSanitizedEnabledFlags(flags_storage, &enabled_experiments);
 
   const Experiment* e = NULL;
   for (size_t i = 0; i < num_experiments; ++i) {
     if (experiments[i].internal_name == internal_name) {
@@ skipping 20 matching lines @@
             enabled_experiments.end()) {
           needs_restart_ = true;
           enabled_experiments.erase(choice_name);
           // Continue on just in case there's a bug and more than one
           // experiment for this choice was enabled.
         }
       }
     }
   }
 
+#if defined(OS_WIN)
+  if (FlagIsStoredInRegistry(internal_name)) {
+    DeleteRegistryValue(HKEY_CURRENT_USER,kRegistryProfilePath,
+        internal_name);
+  }
+#endif
   flags_storage->SetFlags(enabled_experiments);
 }
 
 void FlagsState::RemoveFlagsSwitches(
     std::map<std::string, CommandLine::StringType>* switch_list) {
   for (std::map<std::string, std::string>::const_iterator
            it = flags_switches_.begin(); it != flags_switches_.end(); ++it) {
     switch_list->erase(it->first);
   }
 }
@@ skipping 33 matching lines @@
 }
 
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags