Add notification for media changed, and notify volume mount watcher when it occurs.

components/storage_monitor/storage_monitor_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/storage_monitor_win.h"
 
 #include <windows.h>
 #include <dbt.h>
 #include <fileapi.h>
+#include <shlobj.h>
 
 #include "base/win/wrapped_window_proc.h"
 #include "components/storage_monitor/portable_device_watcher_win.h"
 #include "components/storage_monitor/removable_device_constants.h"
 #include "components/storage_monitor/storage_info.h"
 #include "components/storage_monitor/volume_mount_watcher_win.h"
 
+#define WM_USER_MEDIACHANGED (WM_USER + 5)
+
 // StorageMonitorWin -------------------------------------------------------
 
 namespace storage_monitor {
 
 StorageMonitorWin::StorageMonitorWin(
     VolumeMountWatcherWin* volume_mount_watcher,
     PortableDeviceWatcherWin* portable_device_watcher)
     : window_class_(0),
       instance_(NULL),
       window_(NULL),
+      shell_change_notify_id_(0),
       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());
 }
 
 StorageMonitorWin::~StorageMonitorWin() {
+  if (shell_change_notify_id_)
+    SHChangeNotifyDeregister(shell_change_notify_id_);
   volume_mount_watcher_->SetNotifications(NULL);
   portable_device_watcher_->SetNotifications(NULL);
 
   if (window_)
     DestroyWindow(window_);
 
   if (window_class_)
     UnregisterClass(MAKEINTATOM(window_class_), instance_);
 }
 
 void StorageMonitorWin::Init() {
   WNDCLASSEX window_class;
   base::win::InitializeWindowClass(
       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));
   volume_mount_watcher_->Init();
   portable_device_watcher_->Init(window_);
+  MediaChangeNotificationRegister();
 }
 
 bool StorageMonitorWin::GetStorageInfoForPath(const base::FilePath& path,
                                               StorageInfo* device_info) const {
   DCHECK(device_info);
 
   // TODO(gbillock): Move this logic up to StorageMonitor.
   // If we already know the StorageInfo for the path, just return it.
   // This will account for portable devices as well.
   std::vector<StorageInfo> attached_devices = GetAllAvailableStorages();
@@ skipping 59 matching lines @@
     return msg_wnd->WndProc(hwnd, message, wparam, lparam);
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 LRESULT CALLBACK StorageMonitorWin::WndProc(HWND hwnd, UINT message,
                                             WPARAM wparam, LPARAM lparam) {
   switch (message) {
     case WM_DEVICECHANGE:
       OnDeviceChange(static_cast<UINT>(wparam), lparam);
       return TRUE;
+    case WM_USER_MEDIACHANGED:
+      OnMediaChange(wparam, lparam);
+      return TRUE;
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
+void StorageMonitorWin::MediaChangeNotificationRegister() {
+  LPITEMIDLIST id_list;
+  if (SHGetSpecialFolderLocation(NULL, CSIDL_DRIVES, &id_list) == NOERROR) {
+    SHChangeNotifyEntry notify_entry;
+    notify_entry.pidl = id_list;
+    notify_entry.fRecursive = TRUE;
+    shell_change_notify_id_ = SHChangeNotifyRegister(
+        window_, SHCNRF_ShellLevel, SHCNE_MEDIAINSERTED | SHCNE_MEDIAREMOVED,
+        WM_USER_MEDIACHANGED, 1, &notify_entry);
+    if (!shell_change_notify_id_)
+      DVLOG(1) << "SHChangeNotifyRegister FAILED";
+  } else {
+    DVLOG(1) << "SHGetSpecialFolderLocation FAILED";
+  }
+}
+
 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) {
+  DVLOG(1) << "OnDeviceChange " << event_type << " " << data;
   volume_mount_watcher_->OnWindowMessage(event_type, data);
   portable_device_watcher_->OnWindowMessage(event_type, data);
 }
 
+void StorageMonitorWin::OnMediaChange(WPARAM wparam, LPARAM lparam) {
+  volume_mount_watcher_->OnMediaChange(wparam, lparam);
+}
+
 StorageMonitor* StorageMonitor::CreateInternal() {
   return new StorageMonitorWin(new VolumeMountWatcherWin(),
                                new PortableDeviceWatcherWin());
 }
 
 }  // namespace storage_monitor