Extract and dispatch device uuid in media device attached notification message.

chrome/browser/chromeos/disks/mock_disk_mount_manager.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/chromeos/disks/mock_disk_mount_manager.h"
 
 #include "base/message_loop.h"
+#include "base/stl_util.h"
 #include "base/string_util.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 using testing::_;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::ReturnRef;
 
 namespace chromeos {
 namespace disks {
 
 namespace {
 
 const char* kTestSystemPath = "/this/system/path";
 const char* kTestSystemPathPrefix = "/this/system";
 const char* kTestDevicePath = "/this/device/path";
 const char* kTestMountPath = "/media/foofoo";
 const char* kTestFilePath = "/this/file/path";
 const char* kTestDeviceLabel = "A label";
 const char* kTestDriveLabel = "Another label";
+const char* kTestUuid = "FFFF-FFFF";
 
 }  // namespace
 
 void MockDiskMountManager::AddObserverInternal(
     DiskMountManager::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void MockDiskMountManager::RemoveObserverInternal(
     DiskMountManager::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 MockDiskMountManager::MockDiskMountManager() {
   ON_CALL(*this, AddObserver(_))
       .WillByDefault(Invoke(this, &MockDiskMountManager::AddObserverInternal));
   ON_CALL(*this, RemoveObserver(_))
       .WillByDefault(Invoke(this,
                             &MockDiskMountManager::RemoveObserverInternal));
   ON_CALL(*this, disks())
       .WillByDefault(Invoke(this, &MockDiskMountManager::disksInternal));
 }
 
 MockDiskMountManager::~MockDiskMountManager() {
+  STLDeleteContainerPairSecondPointers(disks_.begin(), disks_.end());
+  disks_.clear();
 }
 
 void MockDiskMountManager::NotifyDeviceInsertEvents() {
   scoped_ptr<DiskMountManager::Disk> disk1(new DiskMountManager::Disk(
       std::string(kTestDevicePath),
       std::string(),
       std::string(kTestSystemPath),
       std::string(kTestFilePath),
       std::string(),
       std::string(kTestDriveLabel),
+      std::string(kTestUuid),
       std::string(kTestSystemPathPrefix),
       DEVICE_TYPE_USB,
       4294967295U,
       false,  // is_parent
       false,  // is_read_only
       true,  // has_media
       false,  // on_boot_device
       false));  // is_hidden
 
   disks_.clear();
@@ skipping 10 matching lines @@
   NotifyDiskChanged(event, disk1.get());
 
   // Disk Changed
   scoped_ptr<DiskMountManager::Disk> disk2(new DiskMountManager::Disk(
       std::string(kTestDevicePath),
       std::string(kTestMountPath),
       std::string(kTestSystemPath),
       std::string(kTestFilePath),
       std::string(kTestDeviceLabel),
       std::string(kTestDriveLabel),
+      std::string(kTestUuid),

[Lei Zhang, 2012/07/30 22:11:32]

either this is correct and the change on line 121 is wrong, or vice versa.

Here we have: drive_label, uuid, system_path_prefix
below we have: uuid, drive_label, system_path_prefix

[kmadhusu, 2012/07/30 22:51:14]

oops. Good catch. Line 98 is correct. Fixed line 121.

       std::string(kTestSystemPathPrefix),
       DEVICE_TYPE_MOBILE,
       1073741824,
       false,  // is_parent
       false,  // is_read_only
       true,  // has_media
       false,  // on_boot_device
       false));  // is_hidden
   disks_.clear();
   disks_.insert(std::pair<std::string, DiskMountManager::Disk*>(
       std::string(kTestDevicePath), disk2.get()));
   event = MOUNT_DISK_CHANGED;
   NotifyDiskChanged(event, disk2.get());
 }
 
 void MockDiskMountManager::NotifyDeviceRemoveEvents() {
   scoped_ptr<DiskMountManager::Disk> disk(new DiskMountManager::Disk(
       std::string(kTestDevicePath),
       std::string(kTestMountPath),
       std::string(kTestSystemPath),
       std::string(kTestFilePath),
       std::string(kTestDeviceLabel),
+      std::string(kTestUuid),
       std::string(kTestDriveLabel),
       std::string(kTestSystemPathPrefix),
       DEVICE_TYPE_SD,
       1073741824,
       false,  // is_parent
       false,  // is_read_only
       true,  // has_media
       false,  // on_boot_device
       false));  // is_hidden
   disks_.clear();
@@ skipping 16 matching lines @@
   EXPECT_CALL(*this, UnmountPath(_))
       .Times(AnyNumber());
   EXPECT_CALL(*this, FormatUnmountedDevice(_))
       .Times(AnyNumber());
   EXPECT_CALL(*this, FormatMountedDevice(_))
       .Times(AnyNumber());
   EXPECT_CALL(*this, UnmountDeviceRecursive(_, _, _))
       .Times(AnyNumber());
 }
 
+void MockDiskMountManager::CreateDiskEntryForMountDevice(
+    const DiskMountManager::MountPointInfo& mount_info,
+    const std::string& device_id) {
+  Disk* disk =  new DiskMountManager::Disk(std::string(mount_info.source_path),

[Ben Chan, 2012/07/30 22:03:59]

nit: remove the extra space after =

[kmadhusu, 2012/07/30 22:51:14]

Done.

+                                           std::string(mount_info.mount_path),
+                                           std::string(),

[Ben Chan, 2012/07/30 22:03:59]

nit: comment what these empty strings are

[kmadhusu, 2012/07/30 22:51:14]

Done.

+                                           std::string(),
+                                           std::string(),
+                                           std::string(),
+                                           std::string(device_id),

[Ben Chan, 2012/07/30 22:03:59]

std::string(device_id) -> device_id

[kmadhusu, 2012/07/30 22:51:14]

Done.

+                                           std::string(),
+                                           DEVICE_TYPE_USB,
+                                           1073741824,
+                                           false,  // is_parent
+                                           false,  // is_read_only
+                                           true,  // has_media
+                                           false,  // on_boot_device
+                                           false);  // is_hidden
+  disks_.insert(std::pair<std::string, DiskMountManager::Disk*>(
+      std::string(mount_info.source_path), disk));
+}
+
+void MockDiskMountManager::RemoveDiskEntryForMountDevice(
+    const DiskMountManager::MountPointInfo& mount_info) {
+  DiskMountManager::DiskMap::iterator it = disks_.find(mount_info.source_path);
+  if (it != disks_.end()) {
+    delete it->second;
+    disks_.erase(it);
+  }
+}
+
 void MockDiskMountManager::NotifyDiskChanged(DiskMountManagerEventType event,
                                              const DiskMountManager::Disk* disk)
 {
   // Make sure we run on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(Observer, observers_, DiskChanged(event, disk));
 }
 
 void MockDiskMountManager::NotifyDeviceChanged(DiskMountManagerEventType event,
                                                const std::string& path) {
   // Make sure we run on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(Observer, observers_, DeviceChanged(event, path));
 }
 
 }  // namespace disks
 }  // namespace chromeos