Adds USB writing for OS X.

chrome/utility/image_writer/disk_unmounter_mac.h

+// Copyright 2014 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.
+
+#ifndef CHROME_UTILITY_IMAGE_WRITER_DISK_UNMOUNTER_MAC_H_
+#define CHROME_UTILITY_IMAGE_WRITER_DISK_UNMOUNTER_MAC_H_
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <DiskArbitration/DiskArbitration.h>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/mac/foundation_util.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread.h"
+
+namespace image_writer {
+
+class ImageWriter;
+
+// Manages the unmounting of disks through Disk Arbitration.  Disk Arbitration
+// has to be run on a thread with a CFRunLoop.  In the utility process neither
+// the main or IO thread have one by default, so we need to manage a new thread
+// which will explicitly have a CFRunLoop-based message pump.  Note that this
+// class can only handle one unmount operation at a time and calling Unmount

[Robert Sesek, 2014/06/06 18:34:06]

That's not quite accurate. You can only ever call Unmount() once, otherwise it
will try to start an already-started thread. I'd maybe restructure the
ctor/Unmount in one of these ways:

1. Do all the work in the ctor and remove Unmount()
2. In the ctor, create the thread, but switch to storing original_thread_ and
image_writer in Unmount()
3. Do all the work in Unmount(), including accepting image_writer as a parameter

I think (2) is probably cleanest. And that allows for multiple unmounts more
cleanly in the future.

[Drew Haven, 2014/06/10 01:13:25]

I agree.  I followed up on that.  Creation of the DiskUnmounter should create
the thread now, and then the callback info is stored when Unmounting.  I also
just cleaned it up so there is just a failure and success callback and the
unmounter doesn't actually care about its caller.

+// again before the continuation returns will cause undefined behavior.
+class DiskUnmounterMac {
+ public:
+  DiskUnmounterMac(base::WeakPtr<ImageWriter> image_writer);
+  virtual ~DiskUnmounterMac();
+
+  // Claims and unmounts the device described by |device_path| and then calls
+  // the |continuation| when complete.  This can be called from any thread.
+  // The continuation will be run on the thread this object was created on.
+  void Unmount(const std::string& device_path,
+               const base::Closure& continuation);
+
+ private:
+  // Handles disk-claimed callbacks.
+  static void DiskClaimed(DADiskRef disk,
+                          DADissenterRef dissenter,
+                          void* context);
+  // Handles when we fail to claim a disk.
+  static DADissenterRef DiskClaimRevoked(DADiskRef disk, void* context);
+  // Handles the disk-unmounted callback.
+  static void DiskUnmounted(DADiskRef disk,
+                            DADissenterRef dissenter,
+                            void* context);
+
+  // A |MessagePumpFactory| for creating the thread.
+  static scoped_ptr<base::MessagePump> CreateMessagePump();
+
+  // Starts the unmount process.  Should be posted to the |cf_thread_|.
+  void UnmountOnWorker(const std::string& device_path);
+
+  // A convenience method for sending an error back to the |image_writer_|.
+  void Error(const std::string& message);
+
+  base::WeakPtr<ImageWriter> image_writer_;
+  base::Closure unmount_continuation_closure_;
+  scoped_refptr<base::MessageLoopProxy> original_thread_;
+
+  base::ScopedCFTypeRef<DADiskRef> disk_;
+  base::ScopedCFTypeRef<DASessionRef> session_;
+
+  // Thread is last to ensure it is stopped before the data members are
+  // destroyed.
+  base::Thread cf_thread_;
+};
+
+}  // namespace image_writer
+
+#endif  // CHROME_UTILITY_IMAGE_WRITER_DISK_UNMOUNTER_MAC_H_