Update uses of UTF conversions in ppapi/, printing/, remoting/, rlz/, sandbox/, skia/, sql/, sync/,…

remoting/host/setup/daemon_controller_delegate_win.cc

 // Copyright 2013 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 "remoting/host/setup/daemon_controller_delegate_win.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
@@ skipping 40 matching lines @@
 // The maximum duration of keeping a reference to an unprivileged instance of
 // the Daemon Controller. This interval should not be too long. If upgrade
 // happens while there is a live reference to a Daemon Controller instance
 // the old binary still can be used. So dropping the references often makes sure
 // that the old binary will go away sooner.
 const int kUnprivilegedTimeoutSec = 60;
 
 void ConfigToString(const base::DictionaryValue& config, ScopedBstr* out) {
   std::string config_str;
   base::JSONWriter::Write(&config, &config_str);
-  ScopedBstr config_scoped_bstr(UTF8ToUTF16(config_str).c_str());
+  ScopedBstr config_scoped_bstr(base::UTF8ToUTF16(config_str).c_str());
   out->Swap(config_scoped_bstr);
 }
 
 DaemonController::State ConvertToDaemonState(DWORD service_state) {
   switch (service_state) {
   case SERVICE_RUNNING:
     return DaemonController::STATE_STARTED;
 
   case SERVICE_CONTINUE_PENDING:
   case SERVICE_START_PENDING:
@@ skipping 104 matching lines @@
   // Get the host configuration.
   ScopedBstr host_config;
   hr = control_->GetConfig(host_config.Receive());
   if (FAILED(hr))
     return scoped_ptr<base::DictionaryValue>();
 
   // Parse the string into a dictionary.
   base::string16 file_content(
       static_cast<BSTR>(host_config), host_config.Length());
   scoped_ptr<base::Value> config(
-      base::JSONReader::Read(UTF16ToUTF8(file_content),
+      base::JSONReader::Read(base::UTF16ToUTF8(file_content),
           base::JSON_ALLOW_TRAILING_COMMAS));
 
   if (!config || config->GetType() != base::Value::TYPE_DICTIONARY)
     return scoped_ptr<base::DictionaryValue>();
 
   return scoped_ptr<base::DictionaryValue>(
       static_cast<base::DictionaryValue*>(config.release()));
 }
 
 void DaemonControllerDelegateWin::SetConfigAndStart(
@@ skipping 74 matching lines @@
   HRESULT hr = ActivateController();
   if (FAILED(hr))
     return std::string();
 
   // Get the version string.
   ScopedBstr version;
   hr = control_->GetVersion(version.Receive());
   if (FAILED(hr))
     return std::string();
 
-  return UTF16ToUTF8(
+  return base::UTF16ToUTF8(
       base::string16(static_cast<BSTR>(version), version.Length()));
 }
 
 DaemonController::UsageStatsConsent
 DaemonControllerDelegateWin::GetUsageStatsConsent() {
   DaemonController::UsageStatsConsent consent;
   consent.supported = true;
   consent.allowed = false;
   consent.set_by_policy = false;
 
@@ skipping 157 matching lines @@
   done.Run(HResultToAsyncResult(hr));
 }
 
 scoped_refptr<DaemonController> DaemonController::Create() {
   scoped_ptr<DaemonController::Delegate> delegate(
       new DaemonControllerDelegateWin());
   return new DaemonController(delegate.Pass());
 }
 
 }  // namespace remoting