Rename all methods accessing Singleton<T> as GetInstance().

chrome/browser/about_flags.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/about_flags.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <set>
@@ skipping 287 matching lines @@
   FlagsState() : needs_restart_(false) {}
   void ConvertFlagsToSwitches(PrefService* prefs, CommandLine* command_line);
   bool IsRestartNeededToCommitChanges();
   void SetExperimentEnabled(
       PrefService* prefs, const std::string& internal_name, bool enable);
   void RemoveFlagsSwitches(
       std::map<std::string, CommandLine::StringType>* switch_list);
   void reset();
 
   // Returns the singleton instance of this class
-  static FlagsState* instance() {
+  static FlagsState* GetInstance() {
     return Singleton<FlagsState>::get();
   }
 
  private:
   bool needs_restart_;
   std::set<std::string> flags_switches_;
 
   DISALLOW_COPY_AND_ASSIGN(FlagsState);
 };
 
@@ skipping 141 matching lines @@
       *is_one_selected = true;
     value->SetBoolean("selected", is_selected);
     result->Append(value);
   }
   return result;
 }
 
 }  // namespace
 
 void ConvertFlagsToSwitches(PrefService* prefs, CommandLine* command_line) {
-  FlagsState::instance()->ConvertFlagsToSwitches(prefs, command_line);
+  FlagsState::GetInstance()->ConvertFlagsToSwitches(prefs, command_line);
 }
 
 ListValue* GetFlagsExperimentsData(PrefService* prefs) {
   std::set<std::string> enabled_experiments;
   GetSanitizedEnabledFlags(prefs, &enabled_experiments);
 
   int current_platform = GetCurrentPlatform();
 
   ListValue* experiments_data = new ListValue();
   for (size_t i = 0; i < num_experiments; ++i) {
@@ skipping 16 matching lines @@
                                             &enabled));
     }
 
     data->SetBoolean("enabled", enabled);
     experiments_data->Append(data);
   }
   return experiments_data;
 }
 
 bool IsRestartNeededToCommitChanges() {
-  return FlagsState::instance()->IsRestartNeededToCommitChanges();
+  return FlagsState::GetInstance()->IsRestartNeededToCommitChanges();
 }
 
 void SetExperimentEnabled(
     PrefService* prefs, const std::string& internal_name, bool enable) {
-  FlagsState::instance()->SetExperimentEnabled(prefs, internal_name, enable);
+  FlagsState::GetInstance()->SetExperimentEnabled(prefs, internal_name, enable);
 }
 
 void RemoveFlagsSwitches(
     std::map<std::string, CommandLine::StringType>* switch_list) {
-  FlagsState::instance()->RemoveFlagsSwitches(switch_list);
+  FlagsState::GetInstance()->RemoveFlagsSwitches(switch_list);
 }
 
 int GetCurrentPlatform() {
 #if defined(OS_MACOSX)
   return kOsMac;
 #elif defined(OS_WIN)
   return kOsWin;
 #elif defined(OS_CHROMEOS)  // Needs to be before the OS_LINUX check.
   return kOsCrOS;
 #elif defined(OS_LINUX)
@@ skipping 148 matching lines @@
 
 } // namespace
 
 namespace testing {
 
 // WARNING: '@' is also used in the html file. If you update this constant you
 // also need to update the html file.
 const char kMultiSeparator[] = "@";
 
 void ClearState() {
-  FlagsState::instance()->reset();
+  FlagsState::GetInstance()->reset();
 }
 
 void SetExperiments(const Experiment* e, size_t count) {
   if (!e) {
     experiments = kExperiments;
     num_experiments = arraysize(kExperiments);
   } else {
     experiments = e;
     num_experiments = count;
   }
 }
 
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags