[Media Gallery] Added code to support mtp device media file system on Windows.

chrome/browser/system_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/system_monitor/portable_device_watcher_win.h"
 
@@ skipping 491 matching lines @@
   if (!IsPortableDeviceStructure(data))
     return;
 
   string16 device_id = GetPnpDeviceId(data);
   if (event_type == DBT_DEVICEARRIVAL)
     HandleDeviceAttachEvent(device_id);
   else if (event_type == DBT_DEVICEREMOVECOMPLETE)
     HandleDeviceDetachEvent(device_id);
 }
 
+bool PortableDeviceWatcherWin::GetMTPStorageInfoFromDeviceId(
+    const std::string& storage_device_id,
+    string16* device_location,
+    string16* storage_object_id) {
+  DCHECK(device_location);
+  DCHECK(storage_object_id);
+  MTPStorageMap::const_iterator storage_map_iter =
+      storage_map_.find(storage_device_id);
+  if (storage_map_iter == storage_map_.end())
+    return false;
+
+  *device_location = storage_map_iter->second.location;
+  MTPDeviceMap::const_iterator device_iter = device_map_.find(*device_location);
+  DCHECK(device_iter != device_map_.end());
+  const StorageObjects& storage_objects = device_iter->second;
+  for (StorageObjects::const_iterator storage_object_iter =
+       storage_objects.begin(); storage_object_iter != storage_objects.end();
+       ++storage_object_iter) {
+    if (storage_device_id == storage_object_iter->object_persistent_id) {
+      *storage_object_id = storage_object_iter->object_temporary_id;
+      break;
+    }
+  }
+  return !storage_object_id->empty();
+}
+
 void PortableDeviceWatcherWin::EnumerateAttachedDevices() {
   DCHECK(media_task_runner_.get());
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   Devices* devices = new Devices;
   base::PostTaskAndReplyWithResult(
       media_task_runner_,
       FROM_HERE,
       base::Bind(&EnumerateAttachedDevicesOnBlockingThread, devices),
       base::Bind(&PortableDeviceWatcherWin::OnDidEnumerateAttachedDevices,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(devices)));
@@ skipping 24 matching lines @@
       base::Bind(&PortableDeviceWatcherWin::OnDidHandleDeviceAttachEvent,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(device_details)));
 }
 
 void PortableDeviceWatcherWin::OnDidHandleDeviceAttachEvent(
     const DeviceDetails* device_details, const bool result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(device_details);
   if (!result)
     return;
-
   const StorageObjects& storage_objects = device_details->storage_objects;
   const string16& name = device_details->name;
   const string16& location = device_details->location;
   DCHECK(!ContainsKey(device_map_, location));
   base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
   DCHECK(system_monitor);
   for (StorageObjects::const_iterator storage_iter = storage_objects.begin();
        storage_iter != storage_objects.end(); ++storage_iter) {
     const std::string& storage_id = storage_iter->object_persistent_id;
     DCHECK(!ContainsKey(storage_map_, storage_id));
@@ skipping 35 matching lines @@
     MTPStorageMap::iterator storage_map_iter = storage_map_.find(storage_id);
     DCHECK(storage_map_iter != storage_map_.end());
     system_monitor->ProcessRemovableStorageDetached(
         storage_map_iter->second.device_id);
     storage_map_.erase(storage_map_iter);
   }
   device_map_.erase(device_iter);
 }
 
 }  // namespace chrome