Add utf_string_conversions to base namespace.

chrome/service/cloud_print/print_system_win.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/service/cloud_print/print_system.h"
 
 #include <objidl.h>
 #include <winspool.h>
 #include <xpsprint.h>
 
@@ skipping 101 matching lines @@
     // TODO(sanjeevr): Handle legacy proxy case (with no prntvpt.dll)
     return E_FAIL;
   }
 
   base::win::ScopedComPtr<IStream> pt_stream;
   HRESULT hr = StreamFromPrintTicket(print_ticket, pt_stream.Receive());
   if (FAILED(hr))
     return hr;
 
   HPTPROVIDER provider = NULL;
-  hr = printing::XPSModule::OpenProvider(UTF8ToWide(printer_name),
+  hr = printing::XPSModule::OpenProvider(base::UTF8ToWide(printer_name),
                                          1,
                                          &provider);
   if (SUCCEEDED(hr)) {
     ULONG size = 0;
     DEVMODE* dm = NULL;
     // Use kPTJobScope, because kPTDocumentScope breaks duplex.
     hr = printing::XPSModule::ConvertPrintTicketToDevMode(provider,
                                                           pt_stream,
                                                           kUserDefaultDevmode,
                                                           kPTJobScope,
@@ skipping 38 matching lines @@
         printing::PrintBackend::CreateInstance(NULL));
     printer_info_ = print_backend->GetPrinterDriverInfo(printer_name);
     child_process_logging::ScopedPrinterInfoSetter prn_info(printer_info_);
 
     delegate_ = delegate;
     // An empty printer name means watch the current server, we need to pass
     // NULL to OpenPrinter.
     LPTSTR printer_name_to_use = NULL;
     std::wstring printer_name_wide;
     if (!printer_name.empty()) {
-      printer_name_wide = UTF8ToWide(printer_name);
+      printer_name_wide = base::UTF8ToWide(printer_name);
       printer_name_to_use = const_cast<LPTSTR>(printer_name_wide.c_str());
     }
     bool ret = false;
     OpenPrinter(printer_name_to_use, printer_.Receive(), NULL);
     if (printer_.IsValid()) {
       printer_change_.Set(FindFirstPrinterChangeNotification(
           printer_, PRINTER_CHANGE_PRINTER|PRINTER_CHANGE_JOB, 0, NULL));
       if (printer_change_.IsValid()) {
         ret = watcher_.StartWatching(printer_change_, this);
       }
@@ skipping 223 matching lines @@
         // We only support PDF and XPS documents for now.
         if (print_data_mime_type == "application/pdf") {
           DevMode pt_dev_mode;
           HRESULT hr = PrintTicketToDevMode(printer_name, print_ticket,
                                             &pt_dev_mode);
           if (FAILED(hr)) {
             NOTREACHED();
             return false;
           }
 
-          HDC dc = CreateDC(L"WINSPOOL", UTF8ToWide(printer_name).c_str(),
+          HDC dc = CreateDC(L"WINSPOOL", base::UTF8ToWide(printer_name).c_str(),
                             NULL, pt_dev_mode.dm_);
           if (!dc) {
             NOTREACHED();
             return false;
           }
           hr = E_FAIL;
           DOCINFO di = {0};
           di.cbSize = sizeof(DOCINFO);
           string16 doc_name = UTF8ToUTF16(job_title);
           DCHECK(printing::PrintBackend::SimplifyDocumentTitle(doc_name) ==
@@ skipping 159 matching lines @@
         if (!job_progress_event_.Get())
           return false;
         scoped_ptr<base::win::ScopedCOMInitializer> com_initializer(
             new base::win::ScopedCOMInitializer(
                 base::win::ScopedCOMInitializer::kMTA));
         base::win::ScopedComPtr<IXpsPrintJobStream> doc_stream;
         base::win::ScopedComPtr<IXpsPrintJobStream> print_ticket_stream;
         bool ret = false;
         // Use nested SUCCEEDED checks because we want a common return point.
         if (SUCCEEDED(printing::XPSPrintModule::StartXpsPrintJob(
-                UTF8ToWide(printer_name).c_str(),
-                UTF8ToWide(job_title).c_str(),
+                base::UTF8ToWide(printer_name).c_str(),
+                base::UTF8ToWide(job_title).c_str(),
                 NULL,
                 job_progress_event_.Get(),
                 NULL,
                 NULL,
                 NULL,
                 xps_print_job_.Receive(),
                 doc_stream.Receive(),
                 print_ticket_stream.Receive()))) {
           ULONG bytes_written = 0;
           if (SUCCEEDED(print_ticket_stream->Write(print_ticket.c_str(),
@@ skipping 165 matching lines @@
     const std::string& print_ticket_data) {
   child_process_logging::ScopedPrinterInfoSetter prn_info(
       print_backend_->GetPrinterDriverInfo(printer_name));
   printing::ScopedXPSInitializer xps_initializer;
   if (!xps_initializer.initialized()) {
     // TODO(sanjeevr): Handle legacy proxy case (with no prntvpt.dll)
     return false;
   }
   bool ret = false;
   HPTPROVIDER provider = NULL;
-  printing::XPSModule::OpenProvider(UTF8ToWide(printer_name.c_str()),
+  printing::XPSModule::OpenProvider(base::UTF8ToWide(printer_name.c_str()),
                                     1,
                                     &provider);
   if (provider) {
     base::win::ScopedComPtr<IStream> print_ticket_stream;
     CreateStreamOnHGlobal(NULL, TRUE, print_ticket_stream.Receive());
     ULONG bytes_written = 0;
     print_ticket_stream->Write(print_ticket_data.c_str(),
                                print_ticket_data.length(),
                                &bytes_written);
     DCHECK(bytes_written == print_ticket_data.length());
@@ skipping 15 matching lines @@
   return ret;
 }
 
 bool PrintSystemWin::GetJobDetails(const std::string& printer_name,
                                    PlatformJobId job_id,
                                    PrintJobDetails *job_details) {
   child_process_logging::ScopedPrinterInfoSetter prn_info(
       print_backend_->GetPrinterDriverInfo(printer_name));
   DCHECK(job_details);
   printing::ScopedPrinterHandle printer_handle;
-  std::wstring printer_name_wide = UTF8ToWide(printer_name);
+  std::wstring printer_name_wide = base::UTF8ToWide(printer_name);
   OpenPrinter(const_cast<LPTSTR>(printer_name_wide.c_str()),
               printer_handle.Receive(), NULL);
   DCHECK(printer_handle.IsValid());
   bool ret = false;
   if (printer_handle.IsValid()) {
     DWORD bytes_needed = 0;
     GetJob(printer_handle, job_id, 1, NULL, 0, &bytes_needed);
     DWORD last_error = GetLastError();
     if (ERROR_INVALID_PARAMETER != last_error) {
       // ERROR_INVALID_PARAMETER normally means that the job id is not valid.
       DCHECK(last_error == ERROR_INSUFFICIENT_BUFFER);
       scoped_array<BYTE> job_info_buffer(new BYTE[bytes_needed]);
       if (GetJob(printer_handle, job_id, 1, job_info_buffer.get(), bytes_needed,
                 &bytes_needed)) {
         JOB_INFO_1 *job_info =
             reinterpret_cast<JOB_INFO_1 *>(job_info_buffer.get());
         if (job_info->pStatus) {
-          WideToUTF8(job_info->pStatus, wcslen(job_info->pStatus),
+          base::WideToUTF8(job_info->pStatus, wcslen(job_info->pStatus),
                      &job_details->status_message);
         }
         job_details->platform_status_flags = job_info->Status;
         if ((job_info->Status & JOB_STATUS_COMPLETE) ||
             (job_info->Status & JOB_STATUS_PRINTED)) {
           job_details->status = PRINT_JOB_STATUS_COMPLETED;
         } else if (job_info->Status & JOB_STATUS_ERROR) {
           job_details->status = PRINT_JOB_STATUS_ERROR;
         } else {
           job_details->status = PRINT_JOB_STATUS_IN_PROGRESS;
@@ skipping 29 matching lines @@
   return "application/pdf";
 }
 
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print