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));
+  UnmountVolumes(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) {
+  LOG(ERROR) << "Unmounting volumes.";

[tbarzic, 2014/05/13 20:09:33]

remove this

[Drew Haven, 2014/05/15 00:30:04]

Oops.  I had trouble deploying a debug build to my chromebook.  Resorted to
logging obviously instead...

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

hehe, I usually do something similar.

+
+  DiskMountManager::GetInstance()->UnmountDeviceRecursively(

[tbarzic, 2014/05/13 20:09:33]

this should be done on UI thread

[Drew Haven, 2014/05/15 00:30:04]

Really?  It feels like a File/IO thing since it either talks to the system or to
another Chrome OS process.  It executed fine and I didn't see it documented
anywhere.  Will fix though.

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

it's just sending dbus message to disks process which does the real work
(I think dbus communication  is done on a separate thread, but that's handled by
layers under DiskMountManager)

+      device_path_.value(),
+      base::Bind(&Operation::UnmountVolumesCallback, this, continuation));
+}
+
+void Operation::UnmountVolumesCallback(const base::Closure& continuation,
+                                       bool success) {
+  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;
+  }
+
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Operation::StartWriteOnUIThread,
+                                     this,
+                                     iter->second->file_path(),
+                                     continuation));
+  AddCleanUpFunction(base::Bind(&ClearImageBurner));
+}
+
+void Operation::StartWriteOnUIThread(const std::string& target_path,
+                                     const base::Closure& continuation) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ImageBurnerClient* burner =
       chromeos::DBusThreadManager::Get()->GetImageBurnerClient();
 
   burner->SetEventHandlers(

[tbarzic, 2014/05/13 20:09:33]

can you add a todo to handle a case where another image burn is in progress at
this point

[Drew Haven, 2014/05/15 00:30:04]

Won't that be handled by the error handler? We make sure that there is only one
burn operation in progress per user-extension already.  I'm guessing that the
ImageBurnerClient cannot handle more than one burn at a time?

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

ImageBurnerClient can handle max one burn operation at a time (though, I'm not
sure anymore if the second request will fail or get queried, probably the
former). The problem here is if there is an operation in progress,
SetEventHandler clears the previous event handlers, so the initial burn
operation will hang (as it won't receive burn finished signal).
I guess this is only problem in multi-profile where you could have more than one
operation-manager (which is profile keyed service).

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

I added a guard to only allow one burn operation at a time per profile on Chrome
OS.  I'm not sure what else I could do if they're in multi-profile other than
change the manager to be browser-keyed.

       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