Cleanup Various bits of Windows StorageMonitor classes.

chrome/browser/storage_monitor/storage_monitor_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/browser/storage_monitor/storage_monitor_win.h"
 
 #include <windows.h>
 #include <dbt.h>
 #include <fileapi.h>
 
 #include "base/win/wrapped_window_proc.h"
 #include "chrome/browser/storage_monitor/portable_device_watcher_win.h"
 #include "chrome/browser/storage_monitor/removable_device_constants.h"
 #include "chrome/browser/storage_monitor/storage_info.h"
 #include "chrome/browser/storage_monitor/volume_mount_watcher_win.h"
 
 namespace chrome {
 
-namespace {
-
-const char16 kWindowClassName[] = L"Chrome_StorageMonitorWindow";
-
-}  // namespace
-
-
 // StorageMonitorWin -------------------------------------------------------
 
 // static
 StorageMonitorWin* StorageMonitorWin::Create() {
   return new StorageMonitorWin(new VolumeMountWatcherWin(),
                                new PortableDeviceWatcherWin());
 }
 
 StorageMonitorWin::StorageMonitorWin(
     VolumeMountWatcherWin* volume_mount_watcher,
@@ skipping 16 matching lines @@
   if (window_)
     DestroyWindow(window_);
 
   if (window_class_)
     UnregisterClass(MAKEINTATOM(window_class_), instance_);
 }
 
 void StorageMonitorWin::Init() {
   WNDCLASSEX window_class;
   base::win::InitializeWindowClass(
-      kWindowClassName,
+      L"Chrome_StorageMonitorWindow",
       &base::win::WrappedWindowProc<StorageMonitorWin::WndProcThunk>,
       0, 0, 0, NULL, NULL, NULL, NULL, NULL,
       &window_class);
   instance_ = window_class.hInstance;
   window_class_ = RegisterClassEx(&window_class);
   DCHECK(window_class_);
 
   window_ = CreateWindow(MAKEINTATOM(window_class_), 0, 0, 0, 0, 0, 0, 0, 0,
                          instance_, 0);
   SetWindowLongPtr(window_, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
@@ skipping 45 matching lines @@
   if (type == StorageInfo::MTP_OR_PTP)
     portable_device_watcher_->EjectDevice(device_id, callback);
   else if (StorageInfo::IsRemovableDevice(device_id))
     volume_mount_watcher_->EjectDevice(device_id, callback);
   else
     callback.Run(EJECT_FAILURE);
 }
 
 bool StorageMonitorWin::GetMTPStorageInfoFromDeviceId(
     const std::string& storage_device_id,
-    string16* device_location,
-    string16* storage_object_id) const {
+    base::string16* device_location,
+    base::string16* storage_object_id) const {
   StorageInfo::Type type;
   StorageInfo::CrackDeviceId(storage_device_id, &type, NULL);
   return ((type == StorageInfo::MTP_OR_PTP) &&
       portable_device_watcher_->GetMTPStorageInfoFromDeviceId(
           storage_device_id, device_location, storage_object_id));
 }
 
 // static
 LRESULT CALLBACK StorageMonitorWin::WndProcThunk(HWND hwnd, UINT message,
                                                  WPARAM wparam, LPARAM lparam) {
@@ skipping 12 matching lines @@
       return TRUE;
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 bool StorageMonitorWin::GetDeviceInfo(const base::FilePath& device_path,
                                       StorageInfo* info) const {
+  DCHECK(info);
+
   // TODO(kmadhusu) Implement PortableDeviceWatcherWin::GetDeviceInfo()
   // function when we have the functionality to add a sub directory of
   // portable device as a media gallery.
   return volume_mount_watcher_->GetDeviceInfo(device_path, info);
 }
 
 void StorageMonitorWin::OnDeviceChange(UINT event_type, LPARAM data) {
   volume_mount_watcher_->OnWindowMessage(event_type, data);
   portable_device_watcher_->OnWindowMessage(event_type, data);
 }
 
 }  // namespace chrome