Rename RemovableDeviceNotifications=>StorageMonitor

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/removable_device_notifications_window_win.h"
+#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/media_storage_util.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/volume_mount_watcher_win.h"
 
 namespace chrome {
 
 namespace {
 
 const char16 kWindowClassName[] = L"Chrome_RemovableDeviceNotificationWindow";
 
 }  // namespace
 
 
-// RemovableDeviceNotificationsWindowWin --------------------------------------
+// StorageMonitorWindowWin --------------------------------------
 
 // static
-RemovableDeviceNotificationsWindowWin*
-    RemovableDeviceNotificationsWindowWin::Create() {
-  return new RemovableDeviceNotificationsWindowWin(
+StorageMonitorWin*
+    StorageMonitorWin::Create() {

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

+  return new StorageMonitorWin(
       new VolumeMountWatcherWin(), new PortableDeviceWatcherWin());

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

 }
 
-RemovableDeviceNotificationsWindowWin::
-    RemovableDeviceNotificationsWindowWin(
+StorageMonitorWin::
+    StorageMonitorWin(

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

     VolumeMountWatcherWin* volume_mount_watcher,
     PortableDeviceWatcherWin* portable_device_watcher)
     : window_class_(0),
       instance_(NULL),
       window_(NULL),
       volume_mount_watcher_(volume_mount_watcher),
       portable_device_watcher_(portable_device_watcher) {
   DCHECK(volume_mount_watcher_);
   DCHECK(portable_device_watcher_);
   volume_mount_watcher_->SetNotifications(receiver());
   portable_device_watcher_->SetNotifications(receiver());
 }
 
-RemovableDeviceNotificationsWindowWin::
-    ~RemovableDeviceNotificationsWindowWin() {
+StorageMonitorWin::
+    ~StorageMonitorWin() {

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line warp.

   volume_mount_watcher_->SetNotifications(NULL);
   portable_device_watcher_->SetNotifications(NULL);
 
   if (window_)
     DestroyWindow(window_);
 
   if (window_class_)
     UnregisterClass(MAKEINTATOM(window_class_), instance_);
 }
 
-void RemovableDeviceNotificationsWindowWin::Init() {
+void StorageMonitorWin::Init() {
   WNDCLASSEX window_class;
   base::win::InitializeWindowClass(
       kWindowClassName,
       &base::win::WrappedWindowProc<
-          RemovableDeviceNotificationsWindowWin::WndProcThunk>,
+          StorageMonitorWin::WndProcThunk>,

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

       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));
   volume_mount_watcher_->Init();
   portable_device_watcher_->Init(window_);
 }
 
-bool RemovableDeviceNotificationsWindowWin::GetStorageInfoForPath(
+bool StorageMonitorWin::GetStorageInfoForPath(
     const base::FilePath& path,
     StorageInfo* device_info) const {

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

   string16 location;
   std::string unique_id;
   string16 name;
   bool removable;
   uint64 total_size_in_bytes;
   if (!GetDeviceInfo(path, &location, &unique_id, &name, &removable,
                      &total_size_in_bytes)) {
     return false;
   }
 
@@ skipping 24 matching lines @@
   }
 
   if (device_info) {
     device_info->device_id = device_id;
     device_info->name = name;
     device_info->location = location;
   }
   return true;
 }
 
-uint64 RemovableDeviceNotificationsWindowWin::GetStorageSize(
+uint64 StorageMonitorWin::GetStorageSize(
     const base::FilePath::StringType& location) const {
   return volume_mount_watcher_->GetStorageSize(location);
 }
 
-bool RemovableDeviceNotificationsWindowWin::GetMTPStorageInfoFromDeviceId(
+bool StorageMonitorWin::GetMTPStorageInfoFromDeviceId(
     const std::string& storage_device_id,
     string16* device_location,
     string16* storage_object_id) const {
   MediaStorageUtil::Type type;
   MediaStorageUtil::CrackDeviceId(storage_device_id, &type, NULL);
   return ((type == MediaStorageUtil::MTP_OR_PTP) &&
       portable_device_watcher_->GetMTPStorageInfoFromDeviceId(
           storage_device_id, device_location, storage_object_id));
 }
 
 // static
-LRESULT CALLBACK RemovableDeviceNotificationsWindowWin::WndProcThunk(
+LRESULT CALLBACK StorageMonitorWin::WndProcThunk(
     HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

-  RemovableDeviceNotificationsWindowWin* msg_wnd =
-      reinterpret_cast<RemovableDeviceNotificationsWindowWin*>(
+  StorageMonitorWin* msg_wnd =
+      reinterpret_cast<StorageMonitorWin*>(
           GetWindowLongPtr(hwnd, GWLP_USERDATA));

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

   if (msg_wnd)
     return msg_wnd->WndProc(hwnd, message, wparam, lparam);
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
-LRESULT CALLBACK RemovableDeviceNotificationsWindowWin::WndProc(
+LRESULT CALLBACK StorageMonitorWin::WndProc(
     HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

   switch (message) {
     case WM_DEVICECHANGE:
       OnDeviceChange(static_cast<UINT>(wparam), lparam);
       return TRUE;
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
-bool RemovableDeviceNotificationsWindowWin::GetDeviceInfo(
+bool StorageMonitorWin::GetDeviceInfo(
     const base::FilePath& device_path, string16* device_location,
     std::string* unique_id, string16* name, bool* removable,
     uint64* total_size_in_bytes) const {

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

reindent; one arg per line, aligned after (

   // 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, device_location,
                                               unique_id, name, removable,
                                               total_size_in_bytes);
 }
 
-void RemovableDeviceNotificationsWindowWin::OnDeviceChange(UINT event_type,
+void StorageMonitorWin::OnDeviceChange(UINT event_type,
                                                            LPARAM data) {

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

nit: line wrap.

   volume_mount_watcher_->OnWindowMessage(event_type, data);
   portable_device_watcher_->OnWindowMessage(event_type, data);
 }
 
 }  // namespace chrome