Move WriteInto to base namespace.

components/storage_monitor/volume_mount_watcher_win.cc

 // Copyright 2014 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 "components/storage_monitor/volume_mount_watcher_win.h"
 
 #include <windows.h>
 
 #include <dbt.h>
 #include <fileapi.h>
@@ skipping 57 matching lines @@
     return FLOPPY;
 
   // Check device strings of the form "X:" and "\\.\X:"
   // For floppy drives, these will return strings like "/Device/Floppy0"
   base::string16 device = mount_point;
   if (base::EndsWith(mount_point, L"\\", false))
     device = mount_point.substr(0, mount_point.length() - 1);
   base::string16 device_path;
   base::string16 device_path_slash;
   DWORD dos_device = QueryDosDevice(
-      device.c_str(), WriteInto(&device_path, kMaxPathBufLen), kMaxPathBufLen);
+      device.c_str(), base::WriteInto(&device_path, kMaxPathBufLen),
+      kMaxPathBufLen);
   base::string16 device_slash = base::string16(L"\\\\.\\");
   device_slash += device;
   DWORD dos_device_slash = QueryDosDevice(
-      device_slash.c_str(), WriteInto(&device_path_slash, kMaxPathBufLen),
+      device_slash.c_str(), base::WriteInto(&device_path_slash, kMaxPathBufLen),
       kMaxPathBufLen);
   if (dos_device == 0 && dos_device_slash == 0)
     return FLOPPY;
   if (device_path.find(L"Floppy") != base::string16::npos ||
       device_path_slash.find(L"Floppy") != base::string16::npos) {
     return FLOPPY;
   }
 
   return REMOVABLE;
 }
@@ skipping 26 matching lines @@
 // Gets mass storage device information given a |device_path|. On success,
 // returns true and fills in |info|.
 // The following msdn blog entry is helpful for understanding disk volumes
 // and how they are treated in Windows:
 // http://blogs.msdn.com/b/adioltean/archive/2005/04/16/408947.aspx.
 bool GetDeviceDetails(const base::FilePath& device_path, StorageInfo* info) {
   DCHECK(info);
 
   base::string16 mount_point;
   if (!GetVolumePathName(device_path.value().c_str(),
-                         WriteInto(&mount_point, kMaxPathBufLen),
+                         base::WriteInto(&mount_point, kMaxPathBufLen),
                          kMaxPathBufLen)) {
     return false;
   }
   mount_point.resize(wcslen(mount_point.c_str()));
 
   // Note: experimentally this code does not spin a floppy drive. It
   // returns a GUID associated with the device, not the volume.
   base::string16 guid;
   if (!GetVolumeNameForVolumeMountPoint(mount_point.c_str(),
-                                        WriteInto(&guid, kMaxPathBufLen),
+                                        base::WriteInto(&guid, kMaxPathBufLen),
                                         kMaxPathBufLen)) {
     return false;
   }
   // In case it has two GUID's (see above mentioned blog), do it again.
   if (!GetVolumeNameForVolumeMountPoint(guid.c_str(),
-                                        WriteInto(&guid, kMaxPathBufLen),
+                                        base::WriteInto(&guid, kMaxPathBufLen),
                                         kMaxPathBufLen)) {
     return false;
   }
 
   // If we're adding a floppy drive, return without querying any more
   // drive metadata -- it will cause the floppy drive to seek.
   // Note: treats FLOPPY as FIXED_MASS_STORAGE. This is intentional.
   DeviceType device_type = GetDeviceType(mount_point);
   if (device_type == FLOPPY) {
     info->set_device_id(StorageInfo::MakeDeviceId(
         StorageInfo::FIXED_MASS_STORAGE, base::UTF16ToUTF8(guid)));
     return true;
   }
 
   StorageInfo::Type type = StorageInfo::FIXED_MASS_STORAGE;
   if (device_type == REMOVABLE) {
     type = StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM;
     if (MediaStorageUtil::HasDcim(base::FilePath(mount_point)))
       type = StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM;
   }
 
   // NOTE: experimentally, this function returns false if there is no volume
   // name set.
   base::string16 volume_label;
   GetVolumeInformationW(device_path.value().c_str(),
-                        WriteInto(&volume_label, kMaxPathBufLen),
+                        base::WriteInto(&volume_label, kMaxPathBufLen),
                         kMaxPathBufLen, NULL, NULL, NULL, NULL, 0);
 
   uint64 total_size_in_bytes = GetVolumeSize(mount_point);
   std::string device_id =
       StorageInfo::MakeDeviceId(type, base::UTF16ToUTF8(guid));
 
   // TODO(gbillock): if volume_label.empty(), get the vendor/model information
   // for the volume.
   *info = StorageInfo(device_id, mount_point, volume_label, base::string16(),
                       base::string16(), total_size_in_bytes);
   return true;
 }
 
 // Returns a vector of all the removable mass storage devices that are
 // connected.
 std::vector<base::FilePath> GetAttachedDevices() {
   std::vector<base::FilePath> result;
   base::string16 volume_name;
-  HANDLE find_handle = FindFirstVolume(WriteInto(&volume_name, kMaxPathBufLen),
-                                       kMaxPathBufLen);
+  HANDLE find_handle = FindFirstVolume(
+      base::WriteInto(&volume_name, kMaxPathBufLen), kMaxPathBufLen);
   if (find_handle == INVALID_HANDLE_VALUE)
     return result;
 
   while (true) {
     base::string16 volume_path;
     DWORD return_count;
-    if (GetVolumePathNamesForVolumeName(volume_name.c_str(),
-                                        WriteInto(&volume_path, kMaxPathBufLen),
-                                        kMaxPathBufLen, &return_count)) {
+    if (GetVolumePathNamesForVolumeName(
+            volume_name.c_str(), base::WriteInto(&volume_path, kMaxPathBufLen),
+            kMaxPathBufLen, &return_count)) {
       result.push_back(base::FilePath(volume_path));
     }
-    if (!FindNextVolume(find_handle, WriteInto(&volume_name, kMaxPathBufLen),
+    if (!FindNextVolume(find_handle,
+                        base::WriteInto(&volume_name, kMaxPathBufLen),
                         kMaxPathBufLen)) {
       if (GetLastError() != ERROR_NO_MORE_FILES)
         DPLOG(ERROR);
       break;
     }
   }
 
   FindVolumeClose(find_handle);
   return result;
 }
@@ skipping 328 matching lines @@
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
 
   device_info_task_runner_->PostTask(
       FROM_HERE, base::Bind(&EjectDeviceInThreadPool, device, callback,
                             device_info_task_runner_, 0));
 }
 
 }  // namespace storage_monitor