Sanitize PrefStore interface.

chrome/service/service_process.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/service/service_process.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/json_pref_store.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/service_process_util.h"
 #include "chrome/service/cloud_print/cloud_print_proxy.h"
 #include "chrome/service/service_ipc_server.h"
+#include "chrome/service/service_process_prefs.h"
 #include "net/base/network_change_notifier.h"
 
 #if defined(ENABLE_REMOTING)
 #include "remoting/base/constants.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/json_host_config.h"
 #endif  // defined(ENABLED_REMOTING)
 
 ServiceProcess* g_service_process = NULL;
@@ skipping 54 matching lines @@
   }
 
   // See if we have been suppiled an LSID in the command line. This LSID will
   // override the credentials we use for Cloud Print.
   std::string lsid = command_line.GetSwitchValueASCII(
           switches::kServiceAccountLsid);
 
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   FilePath pref_path = user_data_dir.Append(chrome::kServiceStateFileName);
-  service_prefs_.reset(new JsonPrefStore(pref_path,
-                                         file_thread_->message_loop_proxy()));
+  service_prefs_.reset(
+      new ServiceProcessPrefs(pref_path, file_thread_->message_loop_proxy()));
   service_prefs_->ReadPrefs();
 
-  DictionaryValue* values = service_prefs_->prefs();
   bool remoting_host_enabled = false;
 
   // For development, we allow forcing the enabling of the host daemon via a
   // commandline flag, regardless of the preference setting.
   //
   // TODO(ajwong): When we've gotten the preference setting workflow more
   // stable, we should remove the command-line flag force-enable.
-  values->GetBoolean(prefs::kRemotingHostEnabled, &remoting_host_enabled);
+  service_prefs_->GetBoolean(prefs::kRemotingHostEnabled,
+                             &remoting_host_enabled);
   remoting_host_enabled |= command_line.HasSwitch(switches::kEnableRemoting);
 
 #if defined(ENABLE_REMOTING)
   // Check if remoting host is already enabled.
   if (remoting_host_enabled) {
     StartChromotingHost();
   }
 #endif
 
   // Enable Cloud Print if needed. First check the command-line.
   bool cloud_print_proxy_enabled =
       command_line.HasSwitch(switches::kEnableCloudPrintProxy);
   if (!cloud_print_proxy_enabled) {
     // Then check if the cloud print proxy was previously enabled.
-    values->GetBoolean(prefs::kCloudPrintProxyEnabled,
-                       &cloud_print_proxy_enabled);
+    service_prefs_->GetBoolean(prefs::kCloudPrintProxyEnabled,
+                               &cloud_print_proxy_enabled);
   }
 
   if (cloud_print_proxy_enabled) {
     GetCloudPrintProxy()->EnableForUser(lsid);
   }
 
   VLOG(1) << "Starting Service Process IPC Server";
   ipc_server_.reset(new ServiceIPCServer(GetServiceProcessChannelName()));
   ipc_server_->Init();
 
@@ skipping 48 matching lines @@
 CloudPrintProxy* ServiceProcess::GetCloudPrintProxy() {
   if (!cloud_print_proxy_.get()) {
     cloud_print_proxy_.reset(new CloudPrintProxy());
     cloud_print_proxy_->Initialize(service_prefs_.get(), this);
   }
   return cloud_print_proxy_.get();
 }
 
 void ServiceProcess::OnCloudPrintProxyEnabled() {
   // Save the preference that we have enabled the cloud print proxy.
-  service_prefs_->prefs()->SetBoolean(prefs::kCloudPrintProxyEnabled, true);
+  service_prefs_->SetBoolean(prefs::kCloudPrintProxyEnabled, true);
   service_prefs_->WritePrefs();
   OnServiceEnabled();
 }
 
 void ServiceProcess::OnCloudPrintProxyDisabled() {
   // Save the preference that we have disabled the cloud print proxy.
-  service_prefs_->prefs()->SetBoolean(prefs::kCloudPrintProxyEnabled, false);
+  service_prefs_->SetBoolean(prefs::kCloudPrintProxyEnabled, false);
   service_prefs_->WritePrefs();
   OnServiceDisabled();
 }
 
 void ServiceProcess::OnServiceEnabled() {
   enabled_services_++;
   if (1 == enabled_services_) {
     ServiceProcessState::GetInstance()->AddToAutoRun();
   }
 }
@@ skipping 91 matching lines @@
                        talk_token_,
                        remoting_directory_->host_id(),
                        remoting_directory_->host_name(),
                        remoting_directory_->host_key_pair());
   remoting_directory_.reset();
   remoting_login_ = "";
   remoting_token_ = "";
   talk_token_ = "";
 
   // Save the preference that we have enabled the remoting host.
-  service_prefs_->prefs()->SetBoolean(prefs::kRemotingHostEnabled, true);
+  service_prefs_->SetBoolean(prefs::kRemotingHostEnabled, true);
 
   // Force writing prefs to the disk.
   service_prefs_->WritePrefs();
 
   // TODO(hclam): If we have a problem we need to send an IPC message back
   // to the client that started this.
   bool ret = StartChromotingHost();
   DCHECK(ret);
 }
 
@@ skipping 63 matching lines @@
 #endif
 
 ServiceProcess::~ServiceProcess() {
   Teardown();
   g_service_process = NULL;
 }
 
 // Disable refcounting for runnable method because it is really not needed
 // when we post tasks on the main message loop.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ServiceProcess);