Adds USB writing for OS X.

chrome/utility/image_writer/image_writer_mac.h

Index: chrome/utility/image_writer/image_writer_mac.h
diff --git a/chrome/utility/image_writer/image_writer_mac.h b/chrome/utility/image_writer/image_writer_mac.h
new file mode 100644
index 0000000000000000000000000000000000000000..d347ae363b1cac1bc4b7d0b588dc04b598d938f2
--- /dev/null
+++ b/chrome/utility/image_writer/image_writer_mac.h
@@ -0,0 +1,73 @@
+// 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_IMAGE_WRITER_MAC_H_
+#define CHROME_UTILITY_IMAGE_WRITER_IMAGE_WRITER_MAC_H_
+
+#include <vector>

[Robert Sesek, 2014/06/05 19:49:48]

nit: C++ system headers come after C system headers, with a blank line between
the two groups.

[Drew Haven, 2014/06/05 22:28:28]

vector is not actually needed here.  Removed.

+#include <CoreFoundation/CoreFoundation.h>
+#include <DiskArbitration/DiskArbitration.h>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/files/file.h"
+#include "base/files/file_path.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.
+class DiskUnmounter : public base::SupportsWeakPtr<DiskUnmounter> {

[Robert Sesek, 2014/06/05 19:49:48]

The general preference is to use WeakPtrFactory rather than SupportsWeakPtr, so
that arbitrary clients can't use the object with ill-defined lifetime semantics.

There was a thread "[chromium-dev] Weak ptrs for derived types?" a while ago
that discussed this. WeakPtr is not threadsafe.

[Drew Haven, 2014/06/05 22:28:28]

So, I looked at the logic and we don't even need a WeakPtr here.  The cf_thread_
is last to ensure the thread is stopped before any of the data members get
touched, so in the case of destruction the callbacks that reference this class
will all have run or been cancelled by the time this method is destroyed.

The only funny part would be if there were a reference to cf_thread_ as it was
stopping and so was in an invalid state.  The only references to cf_thread_ are
from the thread that owns this object so there is no concurrency there, and the
one DCHECK I just added which should have minimal impact.

+ public:
+  DiskUnmounter(base::WeakPtr<ImageWriter> image_writer);
+  virtual ~DiskUnmounter();
+
+  // 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,

[Robert Sesek, 2014/06/05 19:49:48]

Is this class meant to unmount more than one volume, ever? It's hard to tell.

[Drew Haven, 2014/06/05 22:28:28]

No.  The ImageWriter/ImageWriterHandler restrict the thread to one operation at
a time.  This is partially just to keep things simple for the IPCs so they don't
have to track which operation they are talking about.  Multiple requests from
the browser thread should each be spawning their own utility thread and so
should not overlap.

This class is intended to just be an internal implementation detail of the mac
implementation, so I'm assuming that is already handled.  I'll make a note of it
anyway.

+               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 this class is destroyed.
+  base::Thread cf_thread_;
+};
+
+}  // namespace image_writer
+
+#endif  // CHROME_UTILITY_IMAGE_WRITER_IMAGE_WRITER_MAC_H_