Unmounts volumes before writing to a drive.

chrome/browser/extensions/api/image_writer_private/operation_chromeos.cc

 // Copyright 2013 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/extensions/api/image_writer_private/error_messages.h"
 #include "chrome/browser/extensions/api/image_writer_private/operation.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/image_burner_client.h"
+#include "chromeos/disks/disk_mount_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace extensions {
 namespace image_writer {
 
+using chromeos::disks::DiskMountManager;
 using chromeos::ImageBurnerClient;
 using content::BrowserThread;
 
 namespace {
 
 void ClearImageBurner() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&ClearImageBurner));
     return;
   }
 
   chromeos::DBusThreadManager::Get()->
       GetImageBurnerClient()->
       ResetEventHandlers();
 }
 
 }  // namespace
 
 void Operation::Write(const base::Closure& continuation) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   SetStage(image_writer_api::STAGE_WRITE);
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&Operation::StartWriteOnUIThread, this, continuation));
-
-  AddCleanUpFunction(base::Bind(&ClearImageBurner));
+      base::Bind(&Operation::UnmountVolumes, this, continuation));
 }
 
 void Operation::VerifyWrite(const base::Closure& continuation) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   // No verification is available in Chrome OS currently.
   continuation.Run();
 }
 
-void Operation::StartWriteOnUIThread(const base::Closure& continuation) {
+void Operation::UnmountVolumes(const base::Closure& continuation) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DiskMountManager::GetInstance()->UnmountDeviceRecursively(
+      device_path_.value(),
+      base::Bind(&Operation::UnmountVolumesCallback, this, continuation));
+}
+
+void Operation::UnmountVolumesCallback(const base::Closure& continuation,
+                                       bool success) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (!success) {
+    LOG(ERROR) << "Volume unmounting failed.";
+    Error(error::kUnmountVolumesError);
+    return;
+  }
+
+  const DiskMountManager::DiskMap& disks =
+      DiskMountManager::GetInstance()->disks();
+  DiskMountManager::DiskMap::const_iterator iter =
+      disks.find(device_path_.value());
+
+  if (iter == disks.end()) {
+    LOG(ERROR) << "Disk not found in disk list after unmounting volumes.";
+    Error(error::kUnmountVolumesError);
+    return;
+  }
+
+  StartWriteOnUIThread(iter->second->file_path(), continuation);
+}
+
+void Operation::StartWriteOnUIThread(const std::string& target_path,
+                                     const base::Closure& continuation) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ImageBurnerClient* burner =
       chromeos::DBusThreadManager::Get()->GetImageBurnerClient();
 
+  AddCleanUpFunction(base::Bind(&ClearImageBurner));

[tbarzic, 2014/05/15 00:58:58]

AddCleanupFunction has DCHECK that it's on file thread

[Drew Haven, 2014/05/15 02:00:28]

Oh, I built release mode when I tested, so I didn't catch that.  You're right. 
It needs to be on the FILE thread so we don't get concurrent access to the
cleanup function list or try to run them while I'm trying to add to them.

I'm going to add the cleanup way before the write.  I believe it should be fine
to call it that early because even if the operation is interrupted the cleanup
call should not cause harm unless another burn operation was already in progress
somehow.  I've done my best to stop that as no one can use the API twice at the
same time, but I don't think I can stop someone from using the Image Burner at
the same time.

   burner->SetEventHandlers(
       base::Bind(&Operation::OnBurnFinished, this, continuation),
       base::Bind(&Operation::OnBurnProgress, this));
 
   burner->BurnImage(image_path_.value(),
-                    device_path_.value(),
+                    target_path,
                     base::Bind(&Operation::OnBurnError, this));
 }
 
 void Operation::OnBurnFinished(const base::Closure& continuation,
                                const std::string& target_path,
                                bool success,
                                const std::string& error) {
   if (success) {
     SetProgress(kProgressComplete);
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, continuation);
   } else {
     DLOG(ERROR) << "Error encountered while burning: " << error;
     Error(error::kChromeOSImageBurnerError);
   }
 }
 
 void Operation::OnBurnProgress(const std::string& target_path,
                                int64 num_bytes_burnt,
                                int64 total_size) {
   int progress = kProgressComplete * num_bytes_burnt / total_size;
   SetProgress(progress);
 }
 
 void Operation::OnBurnError() {
   Error(error::kChromeOSImageBurnerError);
 }
 
 }  // namespace image_writer
 }  // namespace extensions