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

chrome/browser/storage_monitor/portable_device_watcher_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.
 //
 // Any tasks that communicates with the portable device may take >100ms to
 // complete. Those tasks should be run on an blocking thread instead of the
 // UI thread.
 
 #include "chrome/browser/storage_monitor/portable_device_watcher_win.h"
 
@@ skipping 10 matching lines @@
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_propvariant.h"
 #include "chrome/browser/storage_monitor/media_storage_util.h"
 #include "chrome/browser/storage_monitor/removable_device_constants.h"
 #include "chrome/browser/storage_monitor/storage_info.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace {
 
 // Name of the client application that communicates with the MTP device.
-const char16 kClientName[] = L"Chromium";
+const base::char16 kClientName[] = L"Chromium";
 
 // Name of the sequenced task runner.
 const char kMediaTaskRunnerName[] = "media-task-runner";
 
 // Returns true if |data| represents a class of portable devices.
 bool IsPortableDeviceStructure(LPARAM data) {
   DEV_BROADCAST_HDR* broadcast_hdr =
       reinterpret_cast<DEV_BROADCAST_HDR*>(data);
   if (!broadcast_hdr ||
       (broadcast_hdr->dbch_devicetype != DBT_DEVTYP_DEVICEINTERFACE)) {
@@ skipping 146 matching lines @@
   hr = (*properties_to_read)->Add(key);
   return SUCCEEDED(hr);
 }
 
 // Wrapper function to get content property string value.
 bool GetStringPropertyValue(IPortableDeviceValues* properties_values,
                             REFPROPERTYKEY key,
                             base::string16* value) {
   DCHECK(properties_values);
   DCHECK(value);
-  base::win::ScopedCoMem<char16> buffer;
+  base::win::ScopedCoMem<base::char16> buffer;
   HRESULT hr = properties_values->GetStringValue(key, &buffer);
   if (FAILED(hr))
     return false;
-  *value = static_cast<const char16*>(buffer);
+  *value = static_cast<const base::char16*>(buffer);
   return true;
 }
 
 // Constructs a unique identifier for the object specified by the |object_id|.
 // On success, returns true and fills in |unique_id|.
 bool GetObjectUniqueId(IPortableDevice* device,
                        const base::string16& object_id,
                        base::string16* unique_id) {
   DCHECK(device);
   DCHECK(unique_id);
@@ skipping 193 matching lines @@
   base::win::ScopedComPtr<IPortableDeviceManager> portable_device_mgr;
   if (!GetPortableDeviceManager(&portable_device_mgr))
     return false;
 
   // Get the total number of devices found on the system.
   DWORD pnp_device_count = 0;
   HRESULT hr = portable_device_mgr->GetDevices(NULL, &pnp_device_count);
   if (FAILED(hr))
     return false;
 
-  scoped_ptr<char16*[]> pnp_device_ids(new char16*[pnp_device_count]);
+  scoped_ptr<base::char16*[]> pnp_device_ids(
+      new base::char16*[pnp_device_count]);
   hr = portable_device_mgr->GetDevices(pnp_device_ids.get(), &pnp_device_count);
   if (FAILED(hr))
     return false;
 
   for (DWORD index = 0; index < pnp_device_count; ++index) {
     PortableDeviceWatcherWin::DeviceDetails device_details;
     if (GetDeviceInfoOnBlockingThread(
         portable_device_mgr, pnp_device_ids[index], &device_details))
       devices->push_back(device_details);
     CoTaskMemFree(pnp_device_ids[index]);
@@ skipping 231 matching lines @@
     MTPStorageMap::iterator storage_map_iter = storage_map_.find(storage_id);
     DCHECK(storage_map_iter != storage_map_.end());
     if (storage_notifications_) {
       storage_notifications_->ProcessDetach(
           storage_map_iter->second.device_id());
     }
     storage_map_.erase(storage_map_iter);
   }
   device_map_.erase(device_iter);
 }