Update some uses of char16 to use the base:: namespace.

chrome/browser/component_updater/background_downloader_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 "chrome/browser/component_updater/background_downloader_win.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 
 #include <functional>
@@ skipping 78 matching lines @@
 // of the code to move on to trying other urls or trying other components.
 // Last, after completing a job, irrespective of the outcome, the jobs older
 // than a week are proactively cleaned up.
 
 namespace component_updater {
 
 namespace {
 
 // All jobs created by this module have a specific description so they can
 // be found at run-time or by using system administration tools.
-const char16 kJobDescription[] = L"Chrome Component Updater";
+const base::char16 kJobDescription[] = L"Chrome Component Updater";
 
 // How often the code looks for changes in the BITS job state.
 const int kJobPollingIntervalSec = 10;
 
 // How long BITS waits before retrying a job after the job encountered
 // a transient error. If this value is not set, the BITS default is 10 minutes.
 const int kMinimumRetryDelayMin = 1;
 
 // How long to wait for stuck jobs. Stuck jobs could be queued for too long,
 // have trouble connecting, could be suspended for any reason, or they have
@@ skipping 50 matching lines @@
 
 // Returns the file name, the url, and some per-file progress information.
 // The function out parameters can be NULL if that data is not requested.
 HRESULT GetJobFileProperties(IBackgroundCopyFile* file,
                              base::string16* local_name,
                              base::string16* remote_name,
                              BG_FILE_PROGRESS* progress) {
   HRESULT hr = S_OK;
 
   if (local_name) {
-    ScopedCoMem<char16> name;
+    ScopedCoMem<base::char16> name;
     hr = file->GetLocalName(&name);
     if (FAILED(hr))
       return hr;
     local_name->assign(name);
   }
 
   if (remote_name) {
-    ScopedCoMem<char16> name;
+    ScopedCoMem<base::char16> name;
     hr = file->GetRemoteName(&name);
     if (FAILED(hr))
       return hr;
     remote_name->assign(name);
   }
 
   if (progress) {
     BG_FILE_PROGRESS bg_file_progress = {};
     hr = file->GetProgress(&bg_file_progress);
     if (FAILED(hr))
       return hr;
     *progress = bg_file_progress;
   }
 
   return hr;
 }
 
 HRESULT GetJobDescription(IBackgroundCopyJob* job, const base::string16* name) {
-  ScopedCoMem<char16> description;
+  ScopedCoMem<base::char16> description;
   return job->GetDescription(&description);
 }
 
 // Returns the job error code in |error_code| if the job is in the transient
 // or the final error state. Otherwise, the job error is not available and
 // the function fails.
 HRESULT GetJobError(IBackgroundCopyJob* job, HRESULT* error_code_out) {
   *error_code_out = S_OK;
   ScopedComPtr<IBackgroundCopyError> copy_error;
   HRESULT hr = job->GetError(copy_error.Receive());
@@ skipping 73 matching lines @@
 };
 
 bool JobFileUrlEqual::operator()(IBackgroundCopyJob* job,
                                  const base::string16& remote_name) const {
   std::vector<ScopedComPtr<IBackgroundCopyFile> > files;
   HRESULT hr = GetFilesInJob(job, &files);
   if (FAILED(hr))
     return false;
 
   for (size_t i = 0; i != files.size(); ++i) {
-    ScopedCoMem<char16> name;
+    ScopedCoMem<base::char16> name;
     if (SUCCEEDED(files[i]->GetRemoteName(&name)) &&
         remote_name.compare(name) == 0)
       return true;
   }
 
   return false;
 }
 
 // Creates an instance of the BITS manager.
 HRESULT GetBitsManager(IBackgroundCopyManager** bits_manager) {
@@ skipping 392 matching lines @@
 }
 
 bool BackgroundDownloader::IsStuck() {
   const base::TimeDelta job_stuck_timeout(
       base::TimeDelta::FromMinutes(kJobStuckTimeoutMin));
   return job_stuck_begin_time_ + job_stuck_timeout < base::Time::Now();
 }
 
 }  // namespace component_updater