[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 498 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(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());

[Peter Kasting, 2012/12/21 18:13:30]

This is scary.  What if the UI thread deletes the object while you're doing
this?  I don't see how you can guarantee this is safe.

[kmadhusu, 2013/01/02 19:48:31]

There is a chance that the UI thread may delete this object while the task
runner is running this code.

A better solution for this problem is to call this function on the UI thread.
Therefore, I created a worker class (MTPGetStorageInfoWorker) to get the device
storage details on the UI thread. 

[Peter Kasting, 2013/01/04 21:13:38]

It might be nice to have DCHECKs that you're on the UI thread in all the
functions that are supposed to run on the UI thread, like you already have in
some of them.

[kmadhusu, 2013/01/04 22:14:32]

Done.

+  DCHECK(device_location);
+  DCHECK(storage_object_id);
+  base::AutoLock locked(lock_);
+  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;
-
+  base::AutoLock locked(lock_);
   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 13 matching lines @@
                                                   location);
     system_monitor->ProcessRemovableStorageAttached(
         storage_id, storage_name, GetStoragePathFromStorageId(storage_id));
   }
   device_map_[location] = storage_objects;
 }
 
 void PortableDeviceWatcherWin::HandleDeviceDetachEvent(
     const string16& pnp_device_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  base::AutoLock locked(lock_);
   MTPDeviceMap::iterator device_iter = device_map_.find(pnp_device_id);
   if (device_iter == device_map_.end())
     return;
 
   base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
   DCHECK(system_monitor);
 
   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) {
     std::string storage_id = storage_object_iter->object_persistent_id;
     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