BASELINE: Update Chromium to 52.0.2743.76 and Ninja to 1.7.1

Change-Id: I382f51b959689505a60f8b707255ecb344f7d8b4
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

39 files changed, 376 insertions, 176 deletions

diff --git a/chromium/media/capture/video/android/video_capture_device_android.cc b/chromium/media/capture/video/android/video_capture_device_android.cc
index 38d9c6d8dfb..d42272fe805 100644
--- a/chromium/media/capture/video/android/video_capture_device_android.cc
+++ b/chromium/media/capture/video/android/video_capture_device_android.cc
@@ -8,6 +8,7 @@
 #include <utility>
 
 #include "base/android/jni_android.h"
+#include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/strings/string_number_conversions.h"
 #include "jni/VideoCapture_jni.h"
@@ -40,6 +41,16 @@ VideoCaptureDeviceAndroid::VideoCaptureDeviceAndroid(const Name& device_name)
 
 VideoCaptureDeviceAndroid::~VideoCaptureDeviceAndroid() {
   StopAndDeAllocate();
+  // If there are still |photo_callbacks_|, resolve them with empty datas.
+  {
+    base::AutoLock lock(photo_callbacks_lock_);
+    std::for_each(photo_callbacks_.begin(), photo_callbacks_.end(),
+                  [](const std::unique_ptr<TakePhotoCallback>& callback) {
+                    std::unique_ptr<std::vector<uint8_t>> empty_data(
+                        new std::vector<uint8_t>());
+                    callback->Run("", std::move(empty_data));
+                  });
+  }
 }
 
 bool VideoCaptureDeviceAndroid::Init() {
@@ -54,7 +65,7 @@ bool VideoCaptureDeviceAndroid::Init() {
 
 void VideoCaptureDeviceAndroid::AllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<Client> client) {
+    std::unique_ptr<Client> client) {
   DVLOG(1) << "VideoCaptureDeviceAndroid::AllocateAndStart";
   {
     base::AutoLock lock(lock_);
@@ -134,6 +145,28 @@ void VideoCaptureDeviceAndroid::StopAndDeAllocate() {
   Java_VideoCapture_deallocate(env, j_capture_.obj());
 }
 
+bool VideoCaptureDeviceAndroid::TakePhoto(const TakePhotoCallback& callback) {
+  {
+    base::AutoLock lock(lock_);
+    if (state_ != kCapturing)
+      return false;
+  }
+
+  JNIEnv* env = AttachCurrentThread();
+
+  // Make copy on the heap so we can pass the pointer through JNI.
+  std::unique_ptr<TakePhotoCallback> cb(new TakePhotoCallback(callback));
+  const intptr_t callback_id = reinterpret_cast<intptr_t>(cb.get());
+  if (!Java_VideoCapture_takePhoto(env, j_capture_.obj(), callback_id))
+    return false;
+
+  {
+    base::AutoLock lock(photo_callbacks_lock_);
+    photo_callbacks_.push_back(std::move(cb));
+  }
+  return true;
+}
+
 void VideoCaptureDeviceAndroid::OnFrameAvailable(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
@@ -179,6 +212,36 @@ void VideoCaptureDeviceAndroid::OnError(JNIEnv* env,
                 base::android::ConvertJavaStringToUTF8(env, message));
 }
 
+void VideoCaptureDeviceAndroid::OnPhotoTaken(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& obj,
+    jlong callback_id,
+    const base::android::JavaParamRef<jbyteArray>& data) {
+  DCHECK(callback_id);
+
+  base::AutoLock lock(photo_callbacks_lock_);
+
+  TakePhotoCallback* const cb =
+      reinterpret_cast<TakePhotoCallback*>(callback_id);
+  // Search for the pointer |cb| in the list of |photo_callbacks_|.
+  const auto reference_it =
+      std::find_if(photo_callbacks_.begin(), photo_callbacks_.end(),
+                   [cb](const std::unique_ptr<TakePhotoCallback>& callback) {
+                     return callback.get() == cb;
+                   });
+  if (reference_it == photo_callbacks_.end()) {
+    NOTREACHED() << "|callback_id| not found.";
+    return;
+  }
+
+  std::unique_ptr<std::vector<uint8_t>> native_data(new std::vector<uint8_t>());
+  base::android::JavaByteArrayToByteVector(env, data.obj(), native_data.get());
+
+  cb->Run(native_data->size() ? "image/jpeg" : "", std::move(native_data));
+
+  photo_callbacks_.erase(reference_it);
+}
+
 VideoPixelFormat VideoCaptureDeviceAndroid::GetColorspace() {
   JNIEnv* env = AttachCurrentThread();
   const int current_capture_colorspace =
diff --git a/chromium/media/capture/video/android/video_capture_device_android.h b/chromium/media/capture/video/android/video_capture_device_android.h
index cfddf7d8fb0..3ac88bd3cc7 100644
--- a/chromium/media/capture/video/android/video_capture_device_android.h
+++ b/chromium/media/capture/video/android/video_capture_device_android.h
@@ -54,8 +54,9 @@ class MEDIA_EXPORT VideoCaptureDeviceAndroid : public VideoCaptureDevice {
 
   // VideoCaptureDevice implementation.
   void AllocateAndStart(const VideoCaptureParams& params,
-                        scoped_ptr<Client> client) override;
+                        std::unique_ptr<Client> client) override;
   void StopAndDeAllocate() override;
+  bool TakePhoto(const TakePhotoCallback& photo_callback) override;
 
   // Implement org.chromium.media.VideoCapture.nativeOnFrameAvailable.
   void OnFrameAvailable(JNIEnv* env,
@@ -69,6 +70,12 @@ class MEDIA_EXPORT VideoCaptureDeviceAndroid : public VideoCaptureDevice {
                const base::android::JavaParamRef<jobject>& obj,
                const base::android::JavaParamRef<jstring>& message);
 
+  // Implement org.chromium.media.VideoCapture.nativeOnPhotoTaken.
+  void OnPhotoTaken(JNIEnv* env,
+                    const base::android::JavaParamRef<jobject>& obj,
+                    jlong callback_id,
+                    const base::android::JavaParamRef<jbyteArray>& data);
+
  private:
   enum InternalState {
     kIdle,       // The device is opened but not in use.
@@ -87,7 +94,11 @@ class MEDIA_EXPORT VideoCaptureDeviceAndroid : public VideoCaptureDevice {
   bool got_first_frame_;
   base::TimeTicks expected_next_frame_time_;
   base::TimeDelta frame_interval_;
-  scoped_ptr<VideoCaptureDevice::Client> client_;
+  std::unique_ptr<VideoCaptureDevice::Client> client_;
+
+  // List of |photo_callbacks_| in flight, being served in Java side.
+  base::Lock photo_callbacks_lock_;
+  std::list<std::unique_ptr<TakePhotoCallback>> photo_callbacks_;
 
   Name device_name_;
   VideoCaptureFormat capture_format_;
diff --git a/chromium/media/capture/video/android/video_capture_device_factory_android.cc b/chromium/media/capture/video/android/video_capture_device_factory_android.cc
index 1b931a5e4eb..6b04cdc8bd7 100644
--- a/chromium/media/capture/video/android/video_capture_device_factory_android.cc
+++ b/chromium/media/capture/video/android/video_capture_device_factory_android.cc
@@ -34,21 +34,21 @@ VideoCaptureDeviceFactoryAndroid::createVideoCaptureAndroid(
       nativeVideoCaptureDeviceAndroid));
 }
 
-scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryAndroid::Create(
+std::unique_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryAndroid::Create(
     const VideoCaptureDevice::Name& device_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   int id;
   if (!base::StringToInt(device_name.id(), &id))
-    return scoped_ptr<VideoCaptureDevice>();
+    return std::unique_ptr<VideoCaptureDevice>();
 
-  scoped_ptr<VideoCaptureDeviceAndroid> video_capture_device(
+  std::unique_ptr<VideoCaptureDeviceAndroid> video_capture_device(
       new VideoCaptureDeviceAndroid(device_name));
 
   if (video_capture_device->Init())
     return std::move(video_capture_device);
 
   DLOG(ERROR) << "Error creating Video Capture Device.";
-  return scoped_ptr<VideoCaptureDevice>();
+  return std::unique_ptr<VideoCaptureDevice>();
 }
 
 void VideoCaptureDeviceFactoryAndroid::GetDeviceNames(
diff --git a/chromium/media/capture/video/android/video_capture_device_factory_android.h b/chromium/media/capture/video/android/video_capture_device_factory_android.h
index da500a03518..854e033577a 100644
--- a/chromium/media/capture/video/android/video_capture_device_factory_android.h
+++ b/chromium/media/capture/video/android/video_capture_device_factory_android.h
@@ -28,7 +28,7 @@ class MEDIA_EXPORT VideoCaptureDeviceFactoryAndroid
   VideoCaptureDeviceFactoryAndroid() {}
   ~VideoCaptureDeviceFactoryAndroid() override {}
 
-  scoped_ptr<VideoCaptureDevice> Create(
+  std::unique_ptr<VideoCaptureDevice> Create(
       const VideoCaptureDevice::Name& device_name) override;
   void GetDeviceNames(VideoCaptureDevice::Names* device_names) override;
   void GetDeviceSupportedFormats(
diff --git a/chromium/media/capture/video/fake_video_capture_device.cc b/chromium/media/capture/video/fake_video_capture_device.cc
index 5b61f9c41e9..9e1479d81cf 100644
--- a/chromium/media/capture/video/fake_video_capture_device.cc
+++ b/chromium/media/capture/video/fake_video_capture_device.cc
@@ -15,6 +15,7 @@
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
+#include "ui/gfx/codec/png_codec.h"
 
 namespace media {
 
@@ -72,6 +73,29 @@ void DrawPacman(bool use_argb,
   canvas.drawText(time_string.data(), time_string.length(), 30, 20, paint);
 }
 
+// Creates a PNG-encoded frame and sends it back to |callback|. The other
+// parameters are used to replicate the PacMan rendering.
+void DoTakeFakePhoto(const VideoCaptureDevice::TakePhotoCallback& callback,
+                     const VideoCaptureFormat& capture_format,
+                     base::TimeDelta elapsed_time,
+                     float fake_capture_rate) {
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[VideoFrame::AllocationSize(
+      PIXEL_FORMAT_ARGB, capture_format.frame_size)]);
+
+  DrawPacman(true /* use_argb */, buffer.get(), elapsed_time, fake_capture_rate,
+             capture_format.frame_size);
+
+  std::unique_ptr<std::vector<uint8_t>> encoded_data(
+      new std::vector<uint8_t>());
+  const bool result = gfx::PNGCodec::Encode(
+      buffer.get(), gfx::PNGCodec::FORMAT_RGBA, capture_format.frame_size,
+      capture_format.frame_size.width() * 4, true /* discard_transparency */,
+      std::vector<gfx::PNGCodec::Comment>(), encoded_data.get());
+  DCHECK(result);
+
+  callback.Run("image/png", std::move(encoded_data));
+}
+
 FakeVideoCaptureDevice::FakeVideoCaptureDevice(BufferOwnership buffer_ownership,
                                                float fake_capture_rate)
     : buffer_ownership_(buffer_ownership),
@@ -84,7 +108,7 @@ FakeVideoCaptureDevice::~FakeVideoCaptureDevice() {
 
 void FakeVideoCaptureDevice::AllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   client_ = std::move(client);
@@ -137,6 +161,14 @@ void FakeVideoCaptureDevice::StopAndDeAllocate() {
   client_.reset();
 }
 
+bool FakeVideoCaptureDevice::TakePhoto(
+    const TakePhotoCallback& photo_callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&DoTakeFakePhoto, photo_callback, capture_format_,
+                            elapsed_time_, fake_capture_rate_));
+  return true;
+}
+
 void FakeVideoCaptureDevice::CaptureUsingOwnBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -160,7 +192,7 @@ void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  scoped_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer(
+  std::unique_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer(
       client_->ReserveOutputBuffer(capture_format_.frame_size,
                                    capture_format_.pixel_format,
                                    capture_format_.pixel_storage));
diff --git a/chromium/media/capture/video/fake_video_capture_device.h b/chromium/media/capture/video/fake_video_capture_device.h
index 0112642198b..e7f7e795431 100644
--- a/chromium/media/capture/video/fake_video_capture_device.h
+++ b/chromium/media/capture/video/fake_video_capture_device.h
@@ -10,11 +10,11 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/atomicops.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
@@ -35,8 +35,9 @@ class MEDIA_EXPORT FakeVideoCaptureDevice : public VideoCaptureDevice {
 
   // VideoCaptureDevice implementation.
   void AllocateAndStart(const VideoCaptureParams& params,
-                        scoped_ptr<Client> client) override;
+                        std::unique_ptr<Client> client) override;
   void StopAndDeAllocate() override;
+  bool TakePhoto(const TakePhotoCallback& photo_callback) override;
 
  private:
   void CaptureUsingOwnBuffers(base::TimeTicks expected_execution_time);
@@ -53,9 +54,9 @@ class MEDIA_EXPORT FakeVideoCaptureDevice : public VideoCaptureDevice {
   // Frame rate of the fake video device.
   const float fake_capture_rate_;
 
-  scoped_ptr<VideoCaptureDevice::Client> client_;
+  std::unique_ptr<VideoCaptureDevice::Client> client_;
   // |fake_frame_| is used for capturing on Own Buffers.
-  scoped_ptr<uint8_t[]> fake_frame_;
+  std::unique_ptr<uint8_t[]> fake_frame_;
   // Time when the next beep occurs.
   base::TimeDelta beep_time_;
   // Time since the fake video started rendering frames.
diff --git a/chromium/media/capture/video/fake_video_capture_device_factory.cc b/chromium/media/capture/video/fake_video_capture_device_factory.cc
index e228a5df018..32f62fc866f 100644
--- a/chromium/media/capture/video/fake_video_capture_device_factory.cc
+++ b/chromium/media/capture/video/fake_video_capture_device_factory.cc
@@ -26,7 +26,7 @@ FakeVideoCaptureDeviceFactory::FakeVideoCaptureDeviceFactory()
       fake_vcd_ownership_(FakeVideoCaptureDevice::BufferOwnership::OWN_BUFFERS),
       frame_rate_(kFakeCaptureDefaultFrameRate) {}
 
-scoped_ptr<VideoCaptureDevice> FakeVideoCaptureDeviceFactory::Create(
+std::unique_ptr<VideoCaptureDevice> FakeVideoCaptureDeviceFactory::Create(
     const VideoCaptureDevice::Name& device_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ -35,11 +35,11 @@ scoped_ptr<VideoCaptureDevice> FakeVideoCaptureDeviceFactory::Create(
   for (int n = 0; n < number_of_devices_; ++n) {
     std::string possible_id = base::StringPrintf("/dev/video%d", n);
     if (device_name.id().compare(possible_id) == 0) {
-      return scoped_ptr<VideoCaptureDevice>(
+      return std::unique_ptr<VideoCaptureDevice>(
           new FakeVideoCaptureDevice(fake_vcd_ownership_, frame_rate_));
     }
   }
-  return scoped_ptr<VideoCaptureDevice>();
+  return std::unique_ptr<VideoCaptureDevice>();
 }
 
 void FakeVideoCaptureDeviceFactory::GetDeviceNames(
diff --git a/chromium/media/capture/video/fake_video_capture_device_factory.h b/chromium/media/capture/video/fake_video_capture_device_factory.h
index e780f2a3245..dfdab4db925 100644
--- a/chromium/media/capture/video/fake_video_capture_device_factory.h
+++ b/chromium/media/capture/video/fake_video_capture_device_factory.h
@@ -20,7 +20,7 @@ class MEDIA_EXPORT FakeVideoCaptureDeviceFactory
   FakeVideoCaptureDeviceFactory();
   ~FakeVideoCaptureDeviceFactory() override {}
 
-  scoped_ptr<VideoCaptureDevice> Create(
+  std::unique_ptr<VideoCaptureDevice> Create(
       const VideoCaptureDevice::Name& device_name) override;
   void GetDeviceNames(VideoCaptureDevice::Names* device_names) override;
   void GetDeviceSupportedFormats(
diff --git a/chromium/media/capture/video/fake_video_capture_device_unittest.cc b/chromium/media/capture/video/fake_video_capture_device_unittest.cc
index a33eb3f22fe..c68944f9f5e 100644
--- a/chromium/media/capture/video/fake_video_capture_device_unittest.cc
+++ b/chromium/media/capture/video/fake_video_capture_device_unittest.cc
@@ -6,11 +6,13 @@
 
 #include <stddef.h>
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
@@ -76,36 +78,37 @@ class MockClient : public VideoCaptureDevice::Client {
     frame_cb_.Run(format);
   }
   // Virtual methods for capturing using Client's Buffers.
-  scoped_ptr<Buffer> ReserveOutputBuffer(const gfx::Size& dimensions,
-                                         media::VideoPixelFormat format,
-                                         media::VideoPixelStorage storage) {
+  std::unique_ptr<Buffer> ReserveOutputBuffer(
+      const gfx::Size& dimensions,
+      media::VideoPixelFormat format,
+      media::VideoPixelStorage storage) {
     EXPECT_TRUE((format == media::PIXEL_FORMAT_ARGB &&
                  storage == media::PIXEL_STORAGE_CPU) ||
                 (format == media::PIXEL_FORMAT_I420 &&
                  storage == media::PIXEL_STORAGE_GPUMEMORYBUFFER));
     EXPECT_GT(dimensions.GetArea(), 0);
     const VideoCaptureFormat frame_format(dimensions, 0.0, format);
-    return make_scoped_ptr(
+    return base::WrapUnique(
         new MockBuffer(0, frame_format.ImageAllocationSize()));
   }
-  void OnIncomingCapturedBuffer(scoped_ptr<Buffer> buffer,
+  void OnIncomingCapturedBuffer(std::unique_ptr<Buffer> buffer,
                                 const VideoCaptureFormat& frame_format,
                                 const base::TimeTicks& timestamp) {
     frame_cb_.Run(frame_format);
   }
   void OnIncomingCapturedVideoFrame(
-      scoped_ptr<Buffer> buffer,
+      std::unique_ptr<Buffer> buffer,
       const scoped_refptr<media::VideoFrame>& frame,
       const base::TimeTicks& timestamp) {
     VideoCaptureFormat format(frame->natural_size(), 30.0,
                               PIXEL_FORMAT_I420);
     frame_cb_.Run(format);
   }
-  scoped_ptr<Buffer> ResurrectLastOutputBuffer(
+  std::unique_ptr<Buffer> ResurrectLastOutputBuffer(
       const gfx::Size& dimensions,
       media::VideoPixelFormat format,
       media::VideoPixelStorage storage) {
-    return scoped_ptr<Buffer>();
+    return std::unique_ptr<Buffer>();
   }
   double GetBufferPoolUtilization() const override { return 0.0; }
 
@@ -120,7 +123,7 @@ class DeviceEnumerationListener
                void(VideoCaptureDevice::Names* names));
   // GMock doesn't support move-only arguments, so we use this forward method.
   void OnEnumeratedDevicesCallback(
-      scoped_ptr<VideoCaptureDevice::Names> names) {
+      std::unique_ptr<VideoCaptureDevice::Names> names) {
     OnEnumeratedDevicesCallbackPtr(names.release());
   }
 
@@ -129,6 +132,28 @@ class DeviceEnumerationListener
   virtual ~DeviceEnumerationListener() {}
 };
 
+class PhotoTakenListener : public base::RefCounted<PhotoTakenListener> {
+ public:
+  MOCK_METHOD0(OnCorrectPhotoTaken, void(void));
+  // GMock doesn't support move-only arguments, so we use this forward method.
+  void DoOnPhotoTaken(const std::string& mime_type,
+                      std::unique_ptr<std::vector<uint8_t>> data) {
+    // Only PNG images are supported right now.
+    EXPECT_STREQ("image/png", mime_type.c_str());
+    // Not worth decoding the incoming data. Just check that the header is PNG.
+    // http://www.libpng.org/pub/png/spec/1.2/PNG-Rationale.html#R.PNG-file-signature
+    ASSERT_GT(data->size(), 4u);
+    EXPECT_EQ('P', data->data()[1]);
+    EXPECT_EQ('N', data->data()[2]);
+    EXPECT_EQ('G', data->data()[3]);
+    OnCorrectPhotoTaken();
+  }
+
+ private:
+  friend class base::RefCounted<PhotoTakenListener>;
+  virtual ~PhotoTakenListener() {}
+};
+
 }  // namespace
 
 class FakeVideoCaptureDeviceBase : public ::testing::Test {
@@ -138,9 +163,9 @@ class FakeVideoCaptureDeviceBase : public ::testing::Test {
         client_(new MockClient(
             base::Bind(&FakeVideoCaptureDeviceBase::OnFrameCaptured,
                        base::Unretained(this)))),
-        video_capture_device_factory_(new FakeVideoCaptureDeviceFactory()) {
-    device_enumeration_listener_ = new DeviceEnumerationListener();
-  }
+        device_enumeration_listener_(new DeviceEnumerationListener()),
+        photo_taken_listener_(new PhotoTakenListener()),
+        video_capture_device_factory_(new FakeVideoCaptureDeviceFactory()) {}
 
   void SetUp() override { EXPECT_CALL(*client_, OnError(_, _)).Times(0); }
 
@@ -154,7 +179,7 @@ class FakeVideoCaptureDeviceBase : public ::testing::Test {
     run_loop_->Run();
   }
 
-  scoped_ptr<VideoCaptureDevice::Names> EnumerateDevices() {
+  std::unique_ptr<VideoCaptureDevice::Names> EnumerateDevices() {
     VideoCaptureDevice::Names* names;
     EXPECT_CALL(*device_enumeration_listener_.get(),
                 OnEnumeratedDevicesCallbackPtr(_)).WillOnce(SaveArg<0>(&names));
@@ -163,18 +188,20 @@ class FakeVideoCaptureDeviceBase : public ::testing::Test {
         base::Bind(&DeviceEnumerationListener::OnEnumeratedDevicesCallback,
                    device_enumeration_listener_));
     base::MessageLoop::current()->RunUntilIdle();
-    return scoped_ptr<VideoCaptureDevice::Names>(names);
+    return std::unique_ptr<VideoCaptureDevice::Names>(names);
   }
 
   const VideoCaptureFormat& last_format() const { return last_format_; }
 
   VideoCaptureDevice::Names names_;
-  const scoped_ptr<base::MessageLoop> loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
-  scoped_ptr<MockClient> client_;
-  scoped_refptr<DeviceEnumerationListener> device_enumeration_listener_;
+  const std::unique_ptr<base::MessageLoop> loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<MockClient> client_;
+  const scoped_refptr<DeviceEnumerationListener> device_enumeration_listener_;
+  const scoped_refptr<PhotoTakenListener> photo_taken_listener_;
   VideoCaptureFormat last_format_;
-  const scoped_ptr<VideoCaptureDeviceFactory> video_capture_device_factory_;
+  const std::unique_ptr<VideoCaptureDeviceFactory>
+      video_capture_device_factory_;
 };
 
 class FakeVideoCaptureDeviceTest
@@ -194,10 +221,10 @@ class FakeVideoCaptureDeviceCommandLineTest
       public ::testing::WithParamInterface<CommandLineTestData> {};
 
 TEST_P(FakeVideoCaptureDeviceTest, CaptureUsing) {
-  const scoped_ptr<VideoCaptureDevice::Names> names(EnumerateDevices());
+  const std::unique_ptr<VideoCaptureDevice::Names> names(EnumerateDevices());
   ASSERT_FALSE(names->empty());
 
-  scoped_ptr<VideoCaptureDevice> device(new FakeVideoCaptureDevice(
+  std::unique_ptr<VideoCaptureDevice> device(new FakeVideoCaptureDevice(
       testing::get<0>(GetParam()), testing::get<1>(GetParam())));
   ASSERT_TRUE(device);
 
@@ -221,7 +248,7 @@ INSTANTIATE_TEST_CASE_P(
             Values(20, 29.97, 30, 50, 60)));
 
 TEST_F(FakeVideoCaptureDeviceTest, GetDeviceSupportedFormats) {
-  scoped_ptr<VideoCaptureDevice::Names> names(EnumerateDevices());
+  std::unique_ptr<VideoCaptureDevice::Names> names(EnumerateDevices());
 
   VideoCaptureFormats supported_formats;
 
@@ -248,14 +275,34 @@ TEST_F(FakeVideoCaptureDeviceTest, GetDeviceSupportedFormats) {
   }
 }
 
+TEST_F(FakeVideoCaptureDeviceTest, TakePhoto) {
+  std::unique_ptr<VideoCaptureDevice> device(new FakeVideoCaptureDevice(
+      FakeVideoCaptureDevice::BufferOwnership::OWN_BUFFERS, 30.0));
+  ASSERT_TRUE(device);
+
+  VideoCaptureParams capture_params;
+  capture_params.requested_format.frame_size.SetSize(640, 480);
+  capture_params.requested_format.frame_rate = 30.0;
+  device->AllocateAndStart(capture_params, std::move(client_));
+
+  const VideoCaptureDevice::TakePhotoCallback photo_callback =
+      base::Bind(&PhotoTakenListener::DoOnPhotoTaken, photo_taken_listener_);
+  EXPECT_CALL(*photo_taken_listener_.get(), OnCorrectPhotoTaken()).Times(1);
+  ASSERT_TRUE(device->TakePhoto(photo_callback));
+
+  run_loop_.reset(new base::RunLoop());
+  run_loop_->Run();
+  device->StopAndDeAllocate();
+}
+
 TEST_P(FakeVideoCaptureDeviceCommandLineTest, FrameRate) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kUseFakeDeviceForMediaStream, GetParam().argument);
-  const scoped_ptr<VideoCaptureDevice::Names> names(EnumerateDevices());
+  const std::unique_ptr<VideoCaptureDevice::Names> names(EnumerateDevices());
   ASSERT_FALSE(names->empty());
 
   for (const auto& names_iterator : *names) {
-    scoped_ptr<VideoCaptureDevice> device =
+    std::unique_ptr<VideoCaptureDevice> device =
         video_capture_device_factory_->Create(names_iterator);
     ASSERT_TRUE(device);
 
diff --git a/chromium/media/capture/video/file_video_capture_device.cc b/chromium/media/capture/video/file_video_capture_device.cc
index ce718cd12a4..d06741e705a 100644
--- a/chromium/media/capture/video/file_video_capture_device.cc
+++ b/chromium/media/capture/video/file_video_capture_device.cc
@@ -132,8 +132,8 @@ class Y4mFileParser final : public VideoFileParser {
   const uint8_t* GetNextFrame(int* frame_size) override;
 
  private:
-  scoped_ptr<base::File> file_;
-  scoped_ptr<uint8_t[]> video_frame_;
+  std::unique_ptr<base::File> file_;
+  std::unique_ptr<uint8_t[]> video_frame_;
 
   DISALLOW_COPY_AND_ASSIGN(Y4mFileParser);
 };
@@ -148,7 +148,7 @@ class MjpegFileParser final : public VideoFileParser {
   const uint8_t* GetNextFrame(int* frame_size) override;
 
  private:
-  scoped_ptr<base::MemoryMappedFile> mapped_file_;
+  std::unique_ptr<base::MemoryMappedFile> mapped_file_;
 
   DISALLOW_COPY_AND_ASSIGN(MjpegFileParser);
 };
@@ -264,17 +264,16 @@ const uint8_t* MjpegFileParser::GetNextFrame(int* frame_size) {
 bool FileVideoCaptureDevice::GetVideoCaptureFormat(
     const base::FilePath& file_path,
     media::VideoCaptureFormat* video_format) {
-  scoped_ptr<VideoFileParser> file_parser =
+  std::unique_ptr<VideoFileParser> file_parser =
       GetVideoFileParser(file_path, video_format);
   return file_parser != nullptr;
 }
 
 // static
-scoped_ptr<VideoFileParser>
-FileVideoCaptureDevice::GetVideoFileParser(
+std::unique_ptr<VideoFileParser> FileVideoCaptureDevice::GetVideoFileParser(
     const base::FilePath& file_path,
     media::VideoCaptureFormat* video_format) {
-  scoped_ptr<VideoFileParser> file_parser;
+  std::unique_ptr<VideoFileParser> file_parser;
   std::string file_name(file_path.value().begin(), file_path.value().end());
 
   if (base::EndsWith(file_name, "y4m",
@@ -306,7 +305,7 @@ FileVideoCaptureDevice::~FileVideoCaptureDevice() {
 
 void FileVideoCaptureDevice::AllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(!capture_thread_.IsRunning());
 
@@ -329,7 +328,7 @@ void FileVideoCaptureDevice::StopAndDeAllocate() {
 
 void FileVideoCaptureDevice::OnAllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
 
   client_ = std::move(client);
diff --git a/chromium/media/capture/video/file_video_capture_device.h b/chromium/media/capture/video/file_video_capture_device.h
index af615d4dd4d..fce7b01221e 100644
--- a/chromium/media/capture/video/file_video_capture_device.h
+++ b/chromium/media/capture/video/file_video_capture_device.h
@@ -7,12 +7,12 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/files/file.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "media/capture/video/video_capture_device.h"
@@ -47,21 +47,22 @@ class MEDIA_EXPORT FileVideoCaptureDevice : public VideoCaptureDevice {
 
   // VideoCaptureDevice implementation, class methods.
   ~FileVideoCaptureDevice() override;
-  void AllocateAndStart(const VideoCaptureParams& params,
-                        scoped_ptr<VideoCaptureDevice::Client> client) override;
+  void AllocateAndStart(
+      const VideoCaptureParams& params,
+      std::unique_ptr<VideoCaptureDevice::Client> client) override;
   void StopAndDeAllocate() override;
 
  private:
   // Opens a given file |file_path| for reading, and stores collected format
   // information in |video_format|. Returns the parsed file to the
   // caller, who is responsible for closing it.
-  static scoped_ptr<VideoFileParser> GetVideoFileParser(
+  static std::unique_ptr<VideoFileParser> GetVideoFileParser(
       const base::FilePath& file_path,
       media::VideoCaptureFormat* video_format);
 
   // Called on the |capture_thread_|.
   void OnAllocateAndStart(const VideoCaptureParams& params,
-                          scoped_ptr<Client> client);
+                          std::unique_ptr<Client> client);
   void OnStopAndDeAllocate();
   const uint8_t* GetNextFrame();
   void OnCaptureTask();
@@ -74,9 +75,9 @@ class MEDIA_EXPORT FileVideoCaptureDevice : public VideoCaptureDevice {
   // It is active between OnAllocateAndStart() and OnStopAndDeAllocate().
   base::Thread capture_thread_;
   // The following members belong to |capture_thread_|.
-  scoped_ptr<VideoCaptureDevice::Client> client_;
+  std::unique_ptr<VideoCaptureDevice::Client> client_;
   const base::FilePath file_path_;
-  scoped_ptr<VideoFileParser> file_parser_;
+  std::unique_ptr<VideoFileParser> file_parser_;
   VideoCaptureFormat capture_format_;
   // Target time for the next frame.
   base::TimeTicks next_frame_time_;
diff --git a/chromium/media/capture/video/file_video_capture_device_factory.cc b/chromium/media/capture/video/file_video_capture_device_factory.cc
index aa1b69a27df..71fad974456 100644
--- a/chromium/media/capture/video/file_video_capture_device_factory.cc
+++ b/chromium/media/capture/video/file_video_capture_device_factory.cc
@@ -25,14 +25,14 @@ base::FilePath GetFilePathFromCommandLine() {
   return command_line_file_path;
 }
 
-scoped_ptr<VideoCaptureDevice> FileVideoCaptureDeviceFactory::Create(
+std::unique_ptr<VideoCaptureDevice> FileVideoCaptureDeviceFactory::Create(
     const VideoCaptureDevice::Name& device_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
 #if defined(OS_WIN)
-  return scoped_ptr<VideoCaptureDevice>(new FileVideoCaptureDevice(
+  return std::unique_ptr<VideoCaptureDevice>(new FileVideoCaptureDevice(
       base::FilePath(base::SysUTF8ToWide(device_name.name()))));
 #else
-  return scoped_ptr<VideoCaptureDevice>(
+  return std::unique_ptr<VideoCaptureDevice>(
       new FileVideoCaptureDevice(base::FilePath(device_name.name())));
 #endif
 }
diff --git a/chromium/media/capture/video/file_video_capture_device_factory.h b/chromium/media/capture/video/file_video_capture_device_factory.h
index 5335b2c6e88..f0d7f2ea191 100644
--- a/chromium/media/capture/video/file_video_capture_device_factory.h
+++ b/chromium/media/capture/video/file_video_capture_device_factory.h
@@ -18,7 +18,7 @@ class MEDIA_EXPORT FileVideoCaptureDeviceFactory
   FileVideoCaptureDeviceFactory() {}
   ~FileVideoCaptureDeviceFactory() override {}
 
-  scoped_ptr<VideoCaptureDevice> Create(
+  std::unique_ptr<VideoCaptureDevice> Create(
       const VideoCaptureDevice::Name& device_name) override;
   void GetDeviceNames(VideoCaptureDevice::Names* device_names) override;
   void GetDeviceSupportedFormats(
diff --git a/chromium/media/capture/video/linux/v4l2_capture_delegate.cc b/chromium/media/capture/video/linux/v4l2_capture_delegate.cc
index c49ecb7b5d0..bc0ef75917d 100644
--- a/chromium/media/capture/video/linux/v4l2_capture_delegate.cc
+++ b/chromium/media/capture/video/linux/v4l2_capture_delegate.cc
@@ -169,7 +169,7 @@ void V4L2CaptureDelegate::AllocateAndStart(
     int width,
     int height,
     float frame_rate,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   DCHECK(client);
   client_ = std::move(client);
diff --git a/chromium/media/capture/video/linux/v4l2_capture_delegate.h b/chromium/media/capture/video/linux/v4l2_capture_delegate.h
index 9d4a8b3c150..e2256e1c749 100644
--- a/chromium/media/capture/video/linux/v4l2_capture_delegate.h
+++ b/chromium/media/capture/video/linux/v4l2_capture_delegate.h
@@ -52,7 +52,7 @@ class V4L2CaptureDelegate final
   void AllocateAndStart(int width,
                         int height,
                         float frame_rate,
-                        scoped_ptr<VideoCaptureDevice::Client> client);
+                        std::unique_ptr<VideoCaptureDevice::Client> client);
   void StopAndDeAllocate();
 
   void SetRotation(int rotation);
@@ -77,7 +77,7 @@ class V4L2CaptureDelegate final
   // The following members are only known on AllocateAndStart().
   VideoCaptureFormat capture_format_;
   v4l2_format video_fmt_;
-  scoped_ptr<VideoCaptureDevice::Client> client_;
+  std::unique_ptr<VideoCaptureDevice::Client> client_;
   base::ScopedFD device_fd_;
 
   // Vector of BufferTracker to keep track of mmap()ed pointers and their use.
diff --git a/chromium/media/capture/video/linux/video_capture_device_chromeos.cc b/chromium/media/capture/video/linux/video_capture_device_chromeos.cc
index 5c5e3977398..4685302af6a 100644
--- a/chromium/media/capture/video/linux/video_capture_device_chromeos.cc
+++ b/chromium/media/capture/video/linux/video_capture_device_chromeos.cc
@@ -10,17 +10,17 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "ui/gfx/display.h"
-#include "ui/gfx/display_observer.h"
-#include "ui/gfx/screen.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "ui/display/display.h"
+#include "ui/display/display_observer.h"
+#include "ui/display/screen.h"
 
 namespace media {
 
 // This is a delegate class used to transfer Display change events from the UI
 // thread to the media thread.
 class VideoCaptureDeviceChromeOS::ScreenObserverDelegate
-    : public gfx::DisplayObserver,
+    : public display::DisplayObserver,
       public base::RefCountedThreadSafe<ScreenObserverDelegate> {
  public:
   ScreenObserverDelegate(
@@ -47,9 +47,9 @@ class VideoCaptureDeviceChromeOS::ScreenObserverDelegate
 
   ~ScreenObserverDelegate() override { DCHECK(!capture_device_); }
 
-  void OnDisplayAdded(const gfx::Display& /*new_display*/) override {}
-  void OnDisplayRemoved(const gfx::Display& /*old_display*/) override {}
-  void OnDisplayMetricsChanged(const gfx::Display& display,
+  void OnDisplayAdded(const display::Display& /*new_display*/) override {}
+  void OnDisplayRemoved(const display::Display& /*old_display*/) override {}
+  void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t metrics) override {
     DCHECK(ui_task_runner_->BelongsToCurrentThread());
     if (!(metrics & DISPLAY_METRIC_ROTATION))
@@ -59,7 +59,7 @@ class VideoCaptureDeviceChromeOS::ScreenObserverDelegate
 
   void AddObserverOnUIThread() {
     DCHECK(ui_task_runner_->BelongsToCurrentThread());
-    gfx::Screen* screen = gfx::Screen::GetScreen();
+    display::Screen* screen = display::Screen::GetScreen();
     if (screen) {
       screen->AddObserver(this);
       SendDisplayRotation(screen->GetPrimaryDisplay());
@@ -68,13 +68,13 @@ class VideoCaptureDeviceChromeOS::ScreenObserverDelegate
 
   void RemoveObserverOnUIThread() {
     DCHECK(ui_task_runner_->BelongsToCurrentThread());
-    gfx::Screen* screen = gfx::Screen::GetScreen();
+    display::Screen* screen = display::Screen::GetScreen();
     if (screen)
       screen->RemoveObserver(this);
   }
 
   // Post the screen rotation change from the UI thread to capture thread
-  void SendDisplayRotation(const gfx::Display& display) {
+  void SendDisplayRotation(const display::Display& display) {
     DCHECK(ui_task_runner_->BelongsToCurrentThread());
     capture_task_runner_->PostTask(
         FROM_HERE,
@@ -82,7 +82,7 @@ class VideoCaptureDeviceChromeOS::ScreenObserverDelegate
                    this, display));
   }
 
-  void SendDisplayRotationOnCaptureThread(const gfx::Display& display) {
+  void SendDisplayRotationOnCaptureThread(const display::Display& display) {
     DCHECK(capture_task_runner_->BelongsToCurrentThread());
     if (capture_device_)
       capture_device_->SetDisplayRotation(display);
@@ -107,7 +107,7 @@ VideoCaptureDeviceChromeOS::~VideoCaptureDeviceChromeOS() {
 }
 
 void VideoCaptureDeviceChromeOS::SetDisplayRotation(
-    const gfx::Display& display) {
+    const display::Display& display) {
   if (display.IsInternal())
     SetRotation(display.rotation() * 90);
 }
diff --git a/chromium/media/capture/video/linux/video_capture_device_chromeos.h b/chromium/media/capture/video/linux/video_capture_device_chromeos.h
index 8b5fafcd016..51f5d4765e8 100644
--- a/chromium/media/capture/video/linux/video_capture_device_chromeos.h
+++ b/chromium/media/capture/video/linux/video_capture_device_chromeos.h
@@ -8,9 +8,9 @@
 #include "base/macros.h"
 #include "media/capture/video/linux/video_capture_device_linux.h"
 
-namespace gfx {
+namespace display {
 class Display;
-}  // namespace gfx
+}  // namespace display
 
 namespace media {
 
@@ -27,7 +27,7 @@ class VideoCaptureDeviceChromeOS : public VideoCaptureDeviceLinux {
  private:
   class ScreenObserverDelegate;
 
-  void SetDisplayRotation(const gfx::Display& display);
+  void SetDisplayRotation(const display::Display& display);
   scoped_refptr<ScreenObserverDelegate> screen_observer_delegate_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoCaptureDeviceChromeOS);
 };
diff --git a/chromium/media/capture/video/linux/video_capture_device_factory_linux.cc b/chromium/media/capture/video/linux/video_capture_device_factory_linux.cc
index 000f5488012..4cba194dfb2 100644
--- a/chromium/media/capture/video/linux/video_capture_device_factory_linux.cc
+++ b/chromium/media/capture/video/linux/video_capture_device_factory_linux.cc
@@ -128,7 +128,7 @@ VideoCaptureDeviceFactoryLinux::VideoCaptureDeviceFactoryLinux(
 VideoCaptureDeviceFactoryLinux::~VideoCaptureDeviceFactoryLinux() {
 }
 
-scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryLinux::Create(
+std::unique_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryLinux::Create(
     const VideoCaptureDevice::Name& device_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
 #if defined(OS_CHROMEOS)
@@ -138,7 +138,7 @@ scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryLinux::Create(
   VideoCaptureDeviceLinux* self = new VideoCaptureDeviceLinux(device_name);
 #endif
   if (!self)
-    return scoped_ptr<VideoCaptureDevice>();
+    return std::unique_ptr<VideoCaptureDevice>();
   // Test opening the device driver. This is to make sure it is available.
   // We will reopen it again in our worker thread when someone
   // allocates the camera.
@@ -146,10 +146,10 @@ scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryLinux::Create(
   if (!fd.is_valid()) {
     DLOG(ERROR) << "Cannot open device";
     delete self;
-    return scoped_ptr<VideoCaptureDevice>();
+    return std::unique_ptr<VideoCaptureDevice>();
   }
 
-  return scoped_ptr<VideoCaptureDevice>(self);
+  return std::unique_ptr<VideoCaptureDevice>(self);
 }
 
 void VideoCaptureDeviceFactoryLinux::GetDeviceNames(
diff --git a/chromium/media/capture/video/linux/video_capture_device_factory_linux.h b/chromium/media/capture/video/linux/video_capture_device_factory_linux.h
index 6c6747c26f6..8155206916f 100644
--- a/chromium/media/capture/video/linux/video_capture_device_factory_linux.h
+++ b/chromium/media/capture/video/linux/video_capture_device_factory_linux.h
@@ -23,7 +23,7 @@ class MEDIA_EXPORT VideoCaptureDeviceFactoryLinux
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
   ~VideoCaptureDeviceFactoryLinux() override;
 
-  scoped_ptr<VideoCaptureDevice> Create(
+  std::unique_ptr<VideoCaptureDevice> Create(
       const VideoCaptureDevice::Name& device_name) override;
   void GetDeviceNames(VideoCaptureDevice::Names* device_names) override;
   void GetDeviceSupportedFormats(
diff --git a/chromium/media/capture/video/linux/video_capture_device_linux.cc b/chromium/media/capture/video/linux/video_capture_device_linux.cc
index f2a1d1d0a47..8e99e8668ac 100644
--- a/chromium/media/capture/video/linux/video_capture_device_linux.cc
+++ b/chromium/media/capture/video/linux/video_capture_device_linux.cc
@@ -92,7 +92,7 @@ VideoCaptureDeviceLinux::~VideoCaptureDeviceLinux() {
 
 void VideoCaptureDeviceLinux::AllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(!capture_impl_);
   if (v4l2_thread_.IsRunning())
     return;  // Wrong state.
diff --git a/chromium/media/capture/video/linux/video_capture_device_linux.h b/chromium/media/capture/video/linux/video_capture_device_linux.h
index 0f654db55e8..93a039df65b 100644
--- a/chromium/media/capture/video/linux/video_capture_device_linux.h
+++ b/chromium/media/capture/video/linux/video_capture_device_linux.h
@@ -36,7 +36,7 @@ class VideoCaptureDeviceLinux : public VideoCaptureDevice {
 
   // VideoCaptureDevice implementation.
   void AllocateAndStart(const VideoCaptureParams& params,
-                        scoped_ptr<Client> client) override;
+                        std::unique_ptr<Client> client) override;
   void StopAndDeAllocate() override;
 
  protected:
diff --git a/chromium/media/capture/video/mac/video_capture_device_avfoundation_mac.mm b/chromium/media/capture/video/mac/video_capture_device_avfoundation_mac.mm
index 505e4650e59..0f89a03119e 100644
--- a/chromium/media/capture/video/mac/video_capture_device_avfoundation_mac.mm
+++ b/chromium/media/capture/video/mac/video_capture_device_avfoundation_mac.mm
@@ -38,7 +38,18 @@ enum MacBookVersions {
   MACBOOK_AIR_6,
   MACBOOK_AIR_7,
   MACBOOK_AIR_8,
-  MAX_MACBOOK_VERSION = MACBOOK_AIR_8
+  MACBOOK_AIR_3,
+  MACBOOK_AIR_4,
+  MACBOOK_4,
+  MACBOOK_9,
+  MACBOOK_10,
+  MACBOOK_PRO_10,
+  MACBOOK_PRO_9,
+  MACBOOK_PRO_8,
+  MACBOOK_PRO_7,
+  MACBOOK_PRO_6,
+  MACBOOK_PRO_5,
+  MAX_MACBOOK_VERSION = MACBOOK_PRO_5
 };
 
 MacBookVersions GetMacBookModel(const std::string& model) {
@@ -46,12 +57,17 @@ MacBookVersions GetMacBookModel(const std::string& model) {
     const char* name;
     MacBookVersions version;
   } static const kModelToVersion[] = {
-      {"MacBook5,", MACBOOK_5},          {"MacBook6,", MACBOOK_6},
-      {"MacBook7,", MACBOOK_7},          {"MacBook8,", MACBOOK_8},
-      {"MacBookPro11,", MACBOOK_PRO_11}, {"MacBookPro12,", MACBOOK_PRO_12},
-      {"MacBookPro13,", MACBOOK_PRO_13}, {"MacBookAir5,", MACBOOK_AIR_5},
-      {"MacBookAir6,", MACBOOK_AIR_6},   {"MacBookAir7,", MACBOOK_AIR_7},
-      {"MacBookAir8,", MACBOOK_AIR_8},
+      {"MacBook4,", MACBOOK_4},          {"MacBook5,", MACBOOK_5},
+      {"MacBook6,", MACBOOK_6},          {"MacBook7,", MACBOOK_7},
+      {"MacBook8,", MACBOOK_8},          {"MacBook9,", MACBOOK_9},
+      {"MacBook10,", MACBOOK_10},        {"MacBookPro5,", MACBOOK_PRO_5},
+      {"MacBookPro6,", MACBOOK_PRO_6},   {"MacBookPro7,", MACBOOK_PRO_7},
+      {"MacBookPro8,", MACBOOK_PRO_8},   {"MacBookPro9,", MACBOOK_PRO_9},
+      {"MacBookPro10,", MACBOOK_PRO_10}, {"MacBookPro11,", MACBOOK_PRO_11},
+      {"MacBookPro12,", MACBOOK_PRO_12}, {"MacBookPro13,", MACBOOK_PRO_13},
+      {"MacBookAir3,", MACBOOK_AIR_3},   {"MacBookAir4,", MACBOOK_AIR_4},
+      {"MacBookAir5,", MACBOOK_AIR_5},   {"MacBookAir6,", MACBOOK_AIR_6},
+      {"MacBookAir7,", MACBOOK_AIR_7},   {"MacBookAir8,", MACBOOK_AIR_8},
   };
 
   for (const auto& entry : kModelToVersion) {
diff --git a/chromium/media/capture/video/mac/video_capture_device_decklink_mac.h b/chromium/media/capture/video/mac/video_capture_device_decklink_mac.h
index 94eaa9182d0..4ff251f10cd 100644
--- a/chromium/media/capture/video/mac/video_capture_device_decklink_mac.h
+++ b/chromium/media/capture/video/mac/video_capture_device_decklink_mac.h
@@ -67,13 +67,14 @@ class MEDIA_EXPORT VideoCaptureDeviceDeckLinkMac : public VideoCaptureDevice {
 
  private:
   // VideoCaptureDevice implementation.
-  void AllocateAndStart(const VideoCaptureParams& params,
-                        scoped_ptr<VideoCaptureDevice::Client> client) override;
+  void AllocateAndStart(
+      const VideoCaptureParams& params,
+      std::unique_ptr<VideoCaptureDevice::Client> client) override;
   void StopAndDeAllocate() override;
 
   // Protects concurrent setting and using of |client_|.
   base::Lock lock_;
-  scoped_ptr<VideoCaptureDevice::Client> client_;
+  std::unique_ptr<VideoCaptureDevice::Client> client_;
 
   // Reference counted handle to the DeckLink capture delegate, ref counted by
   // the DeckLink SDK as well.
diff --git a/chromium/media/capture/video/mac/video_capture_device_decklink_mac.mm b/chromium/media/capture/video/mac/video_capture_device_decklink_mac.mm
index 3841be64f27..b075c4b234a 100644
--- a/chromium/media/capture/video/mac/video_capture_device_decklink_mac.mm
+++ b/chromium/media/capture/video/mac/video_capture_device_decklink_mac.mm
@@ -477,7 +477,7 @@ void VideoCaptureDeviceDeckLinkMac::SendLogString(const std::string& message) {
 
 void VideoCaptureDeviceDeckLinkMac::AllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   client_ = std::move(client);
   if (decklink_capture_delegate_.get())
diff --git a/chromium/media/capture/video/mac/video_capture_device_factory_mac.h b/chromium/media/capture/video/mac/video_capture_device_factory_mac.h
index 3be9226985b..a8fbab83369 100644
--- a/chromium/media/capture/video/mac/video_capture_device_factory_mac.h
+++ b/chromium/media/capture/video/mac/video_capture_device_factory_mac.h
@@ -19,11 +19,13 @@ class MEDIA_EXPORT VideoCaptureDeviceFactoryMac
   VideoCaptureDeviceFactoryMac();
   ~VideoCaptureDeviceFactoryMac() override;
 
-  scoped_ptr<VideoCaptureDevice> Create(
+  std::unique_ptr<VideoCaptureDevice> Create(
       const VideoCaptureDevice::Name& device_name) override;
   void GetDeviceNames(VideoCaptureDevice::Names* device_names) override;
-  void EnumerateDeviceNames(const base::Callback<
-      void(scoped_ptr<media::VideoCaptureDevice::Names>)>& callback) override;
+  void EnumerateDeviceNames(
+      const base::Callback<
+          void(std::unique_ptr<media::VideoCaptureDevice::Names>)>& callback)
+      override;
   void GetDeviceSupportedFormats(
       const VideoCaptureDevice::Name& device,
       VideoCaptureFormats* supported_formats) override;
diff --git a/chromium/media/capture/video/mac/video_capture_device_factory_mac.mm b/chromium/media/capture/video/mac/video_capture_device_factory_mac.mm
index 682cc07becc..42214588faf 100644
--- a/chromium/media/capture/video/mac/video_capture_device_factory_mac.mm
+++ b/chromium/media/capture/video/mac/video_capture_device_factory_mac.mm
@@ -52,13 +52,13 @@ VideoCaptureDeviceFactoryMac::VideoCaptureDeviceFactoryMac() {
 VideoCaptureDeviceFactoryMac::~VideoCaptureDeviceFactoryMac() {
 }
 
-scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryMac::Create(
+std::unique_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryMac::Create(
     const VideoCaptureDevice::Name& device_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(device_name.capture_api_type(),
             VideoCaptureDevice::Name::API_TYPE_UNKNOWN);
 
-  scoped_ptr<VideoCaptureDevice> capture_device;
+  std::unique_ptr<VideoCaptureDevice> capture_device;
   if (device_name.capture_api_type() == VideoCaptureDevice::Name::DECKLINK) {
     capture_device.reset(new VideoCaptureDeviceDeckLinkMac(device_name));
   } else {
@@ -69,7 +69,7 @@ scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryMac::Create(
       capture_device.reset();
     }
   }
-  return scoped_ptr<VideoCaptureDevice>(std::move(capture_device));
+  return std::unique_ptr<VideoCaptureDevice>(std::move(capture_device));
 }
 
 void VideoCaptureDeviceFactoryMac::GetDeviceNames(
@@ -106,10 +106,11 @@ void VideoCaptureDeviceFactoryMac::GetDeviceNames(
   VideoCaptureDeviceDeckLinkMac::EnumerateDevices(device_names);
 }
 
-void VideoCaptureDeviceFactoryMac::EnumerateDeviceNames(const base::Callback<
-    void(scoped_ptr<media::VideoCaptureDevice::Names>)>& callback) {
+void VideoCaptureDeviceFactoryMac::EnumerateDeviceNames(
+    const base::Callback<
+        void(std::unique_ptr<media::VideoCaptureDevice::Names>)>& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  scoped_ptr<VideoCaptureDevice::Names> device_names(
+  std::unique_ptr<VideoCaptureDevice::Names> device_names(
       new VideoCaptureDevice::Names());
   GetDeviceNames(device_names.get());
   callback.Run(std::move(device_names));
diff --git a/chromium/media/capture/video/mac/video_capture_device_mac.h b/chromium/media/capture/video/mac/video_capture_device_mac.h
index a12bf4fd0ef..d949c6985c1 100644
--- a/chromium/media/capture/video/mac/video_capture_device_mac.h
+++ b/chromium/media/capture/video/mac/video_capture_device_mac.h
@@ -58,8 +58,9 @@ class VideoCaptureDeviceMac : public VideoCaptureDevice {
   ~VideoCaptureDeviceMac() override;
 
   // VideoCaptureDevice implementation.
-  void AllocateAndStart(const VideoCaptureParams& params,
-                        scoped_ptr<VideoCaptureDevice::Client> client) override;
+  void AllocateAndStart(
+      const VideoCaptureParams& params,
+      std::unique_ptr<VideoCaptureDevice::Client> client) override;
   void StopAndDeAllocate() override;
 
   bool Init(VideoCaptureDevice::Name::CaptureApiType capture_api_type);
@@ -88,7 +89,7 @@ class VideoCaptureDeviceMac : public VideoCaptureDevice {
   enum InternalState { kNotInitialized, kIdle, kCapturing, kError };
 
   Name device_name_;
-  scoped_ptr<VideoCaptureDevice::Client> client_;
+  std::unique_ptr<VideoCaptureDevice::Client> client_;
 
   VideoCaptureFormat capture_format_;
 
diff --git a/chromium/media/capture/video/mac/video_capture_device_mac.mm b/chromium/media/capture/video/mac/video_capture_device_mac.mm
index 6979a31b211..e3c14edfa5e 100644
--- a/chromium/media/capture/video/mac/video_capture_device_mac.mm
+++ b/chromium/media/capture/video/mac/video_capture_device_mac.mm
@@ -21,7 +21,7 @@
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/thread_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #import "media/base/mac/avfoundation_glue.h"
 #include "media/base/timestamp_constants.h"
@@ -326,7 +326,7 @@ VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
 
 void VideoCaptureDeviceMac::AllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ != kIdle) {
     return;
diff --git a/chromium/media/capture/video/video_capture_device.cc b/chromium/media/capture/video/video_capture_device.cc
index 61a752f7ca8..8ee1f9e39d2 100644
--- a/chromium/media/capture/video/video_capture_device.cc
+++ b/chromium/media/capture/video/video_capture_device.cc
@@ -75,6 +75,8 @@ VideoCaptureDevice::Name::Name(const std::string& name,
 }
 #endif
 
+VideoCaptureDevice::Name::Name(const Name& other) = default;
+
 VideoCaptureDevice::Name::~Name() {
 }
 
@@ -139,6 +141,11 @@ VideoCaptureDevice::Client::Buffer::~Buffer() {
 VideoCaptureDevice::~VideoCaptureDevice() {
 }
 
+bool VideoCaptureDevice::TakePhoto(const TakePhotoCallback& photo_callback) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
 PowerLineFrequency VideoCaptureDevice::GetPowerLineFrequencyForLocation()
     const {
   const std::string current_country = base::CountryCodeForCurrentTimezone();
diff --git a/chromium/media/capture/video/video_capture_device.h b/chromium/media/capture/video/video_capture_device.h
index 6983865b680..24dec1d1857 100644
--- a/chromium/media/capture/video/video_capture_device.h
+++ b/chromium/media/capture/video/video_capture_device.h
@@ -16,12 +16,12 @@
 #include <stdint.h>
 
 #include <list>
+#include <memory>
 #include <string>
 
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ -93,6 +93,7 @@ class MEDIA_EXPORT VideoCaptureDevice {
          const CaptureApiType api_type,
          const TransportType transport_type);
 #endif
+    Name(const Name& other);
     ~Name();
 
     // Friendly name of a device
@@ -216,7 +217,7 @@ class MEDIA_EXPORT VideoCaptureDevice {
     //
     // The output buffer stays reserved and mapped for use until the Buffer
     // object is destroyed or returned.
-    virtual scoped_ptr<Buffer> ReserveOutputBuffer(
+    virtual std::unique_ptr<Buffer> ReserveOutputBuffer(
         const gfx::Size& dimensions,
         VideoPixelFormat format,
         VideoPixelStorage storage) = 0;
@@ -228,11 +229,11 @@ class MEDIA_EXPORT VideoCaptureDevice {
     // ReserveOutputBuffer(), delivery is guaranteed and will require no
     // additional copies in the browser process.
     virtual void OnIncomingCapturedBuffer(
-        scoped_ptr<Buffer> buffer,
+        std::unique_ptr<Buffer> buffer,
         const VideoCaptureFormat& frame_format,
         const base::TimeTicks& timestamp) = 0;
     virtual void OnIncomingCapturedVideoFrame(
-        scoped_ptr<Buffer> buffer,
+        std::unique_ptr<Buffer> buffer,
         const scoped_refptr<VideoFrame>& frame,
         const base::TimeTicks& timestamp) = 0;
 
@@ -241,7 +242,7 @@ class MEDIA_EXPORT VideoCaptureDevice {
     // Buffer has not been preserved, or if the |dimensions|, |format|, or
     // |storage| disagree with how it was reserved via ReserveOutputBuffer().
     // When this operation fails, nullptr will be returned.
-    virtual scoped_ptr<Buffer> ResurrectLastOutputBuffer(
+    virtual std::unique_ptr<Buffer> ResurrectLastOutputBuffer(
         const gfx::Size& dimensions,
         VideoPixelFormat format,
         VideoPixelStorage storage) = 0;
@@ -264,7 +265,7 @@ class MEDIA_EXPORT VideoCaptureDevice {
   // Prepares the video capturer for use. StopAndDeAllocate() must be called
   // before the object is deleted.
   virtual void AllocateAndStart(const VideoCaptureParams& params,
-                                scoped_ptr<Client> client) = 0;
+                                std::unique_ptr<Client> client) = 0;
 
   // In cases where the video capturer self-pauses (e.g., a screen capturer
   // where the screen's content has not changed in a while), consumers may call
@@ -298,6 +299,16 @@ class MEDIA_EXPORT VideoCaptureDevice {
   // happens first.
   virtual void StopAndDeAllocate() = 0;
 
+  // Asynchronously takes a photo, possibly reconfiguring the capture objects
+  // and/or interrupting the capture flow. Returns false if taking the picture
+  // could not be scheduled at all, or else runs |photo_callback| (on the thread
+  // where TakePhoto() is run).
+  using TakePhotoCallback =
+      base::Callback<void(const std::string&,
+                          std::unique_ptr<std::vector<uint8_t>>)>;
+  virtual bool TakePhoto(const TakePhotoCallback& photo_callback)
+      WARN_UNUSED_RESULT;
+
   // Gets the power line frequency, either from the params if specified by the
   // user or from the current system time zone.
   PowerLineFrequency GetPowerLineFrequency(
diff --git a/chromium/media/capture/video/video_capture_device_factory.cc b/chromium/media/capture/video/video_capture_device_factory.cc
index 9efc8baeeee..39aa62aba6f 100644
--- a/chromium/media/capture/video/video_capture_device_factory.cc
+++ b/chromium/media/capture/video/video_capture_device_factory.cc
@@ -15,7 +15,8 @@
 namespace media {
 
 // static
-scoped_ptr<VideoCaptureDeviceFactory> VideoCaptureDeviceFactory::CreateFactory(
+std::unique_ptr<VideoCaptureDeviceFactory>
+VideoCaptureDeviceFactory::CreateFactory(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
@@ -23,16 +24,16 @@ scoped_ptr<VideoCaptureDeviceFactory> VideoCaptureDeviceFactory::CreateFactory(
   // present, otherwise use the normal, platform-dependent, device factory.
   if (command_line->HasSwitch(switches::kUseFakeDeviceForMediaStream)) {
     if (command_line->HasSwitch(switches::kUseFileForFakeVideoCapture)) {
-      return scoped_ptr<VideoCaptureDeviceFactory>(
+      return std::unique_ptr<VideoCaptureDeviceFactory>(
           new media::FileVideoCaptureDeviceFactory());
     } else {
-      return scoped_ptr<VideoCaptureDeviceFactory>(
+      return std::unique_ptr<VideoCaptureDeviceFactory>(
           new media::FakeVideoCaptureDeviceFactory());
     }
   } else {
     // |ui_task_runner| is needed for the Linux ChromeOS factory to retrieve
     // screen rotations.
-    return scoped_ptr<VideoCaptureDeviceFactory>(
+    return std::unique_ptr<VideoCaptureDeviceFactory>(
         CreateVideoCaptureDeviceFactory(ui_task_runner));
   }
 }
@@ -44,11 +45,12 @@ VideoCaptureDeviceFactory::VideoCaptureDeviceFactory() {
 VideoCaptureDeviceFactory::~VideoCaptureDeviceFactory() {
 }
 
-void VideoCaptureDeviceFactory::EnumerateDeviceNames(const base::Callback<
-    void(scoped_ptr<media::VideoCaptureDevice::Names>)>& callback) {
+void VideoCaptureDeviceFactory::EnumerateDeviceNames(
+    const base::Callback<
+        void(std::unique_ptr<media::VideoCaptureDevice::Names>)>& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
-  scoped_ptr<VideoCaptureDevice::Names> device_names(
+  std::unique_ptr<VideoCaptureDevice::Names> device_names(
       new VideoCaptureDevice::Names());
   GetDeviceNames(device_names.get());
   callback.Run(std::move(device_names));
diff --git a/chromium/media/capture/video/video_capture_device_factory.h b/chromium/media/capture/video/video_capture_device_factory.h
index a0f3c80667f..83698ec6a79 100644
--- a/chromium/media/capture/video/video_capture_device_factory.h
+++ b/chromium/media/capture/video/video_capture_device_factory.h
@@ -17,19 +17,20 @@ namespace media {
 // in Device Thread (a.k.a. Audio Thread).
 class MEDIA_EXPORT VideoCaptureDeviceFactory {
  public:
-  static scoped_ptr<VideoCaptureDeviceFactory> CreateFactory(
+  static std::unique_ptr<VideoCaptureDeviceFactory> CreateFactory(
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
 
   VideoCaptureDeviceFactory();
   virtual ~VideoCaptureDeviceFactory();
 
   // Creates a VideoCaptureDevice object. Returns NULL if something goes wrong.
-  virtual scoped_ptr<VideoCaptureDevice> Create(
+  virtual std::unique_ptr<VideoCaptureDevice> Create(
       const VideoCaptureDevice::Name& device_name) = 0;
 
   // Asynchronous version of GetDeviceNames calling back to |callback|.
-  virtual void EnumerateDeviceNames(const base::Callback<
-      void(scoped_ptr<media::VideoCaptureDevice::Names>)>& callback);
+  virtual void EnumerateDeviceNames(
+      const base::Callback<
+          void(std::unique_ptr<media::VideoCaptureDevice::Names>)>& callback);
 
   // Gets the supported formats of a particular device attached to the system.
   // This method should be called before allocating or starting a device. In
diff --git a/chromium/media/capture/video/video_capture_device_unittest.cc b/chromium/media/capture/video/video_capture_device_unittest.cc
index 2420181f072..85e27181329 100644
--- a/chromium/media/capture/video/video_capture_device_unittest.cc
+++ b/chromium/media/capture/video/video_capture_device_unittest.cc
@@ -6,17 +6,18 @@
 
 #include <stddef.h>
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
-#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "media/base/video_capture_types.h"
 #include "media/capture/video/video_capture_device_factory.h"
@@ -105,32 +106,32 @@ class MockClient : public VideoCaptureDevice::Client {
     main_thread_->PostTask(FROM_HERE, base::Bind(frame_cb_, format));
   }
 
-  // Trampoline methods to workaround GMOCK problems with scoped_ptr<>.
-  scoped_ptr<Buffer> ReserveOutputBuffer(
+  // Trampoline methods to workaround GMOCK problems with std::unique_ptr<>.
+  std::unique_ptr<Buffer> ReserveOutputBuffer(
       const gfx::Size& dimensions,
       media::VideoPixelFormat format,
       media::VideoPixelStorage storage) override {
     DoReserveOutputBuffer();
     NOTREACHED() << "This should never be called";
-    return scoped_ptr<Buffer>();
+    return std::unique_ptr<Buffer>();
   }
-  void OnIncomingCapturedBuffer(scoped_ptr<Buffer> buffer,
+  void OnIncomingCapturedBuffer(std::unique_ptr<Buffer> buffer,
                                 const VideoCaptureFormat& frame_format,
                                 const base::TimeTicks& timestamp) override {
     DoOnIncomingCapturedBuffer();
   }
-  void OnIncomingCapturedVideoFrame(scoped_ptr<Buffer> buffer,
+  void OnIncomingCapturedVideoFrame(std::unique_ptr<Buffer> buffer,
                                     const scoped_refptr<VideoFrame>& frame,
                                     const base::TimeTicks& timestamp) override {
     DoOnIncomingCapturedVideoFrame();
   }
-  scoped_ptr<Buffer> ResurrectLastOutputBuffer(
+  std::unique_ptr<Buffer> ResurrectLastOutputBuffer(
       const gfx::Size& dimensions,
       media::VideoPixelFormat format,
       media::VideoPixelStorage storage) {
     DoResurrectLastOutputBuffer();
     NOTREACHED() << "This should never be called";
-    return scoped_ptr<Buffer>();
+    return std::unique_ptr<Buffer>();
   }
 
  private:
@@ -145,7 +146,7 @@ class DeviceEnumerationListener
                void(VideoCaptureDevice::Names* names));
   // GMock doesn't support move-only arguments, so we use this forward method.
   void OnEnumeratedDevicesCallback(
-      scoped_ptr<VideoCaptureDevice::Names> names) {
+      std::unique_ptr<VideoCaptureDevice::Names> names) {
     OnEnumeratedDevicesCallbackPtr(names.release());
   }
 
@@ -200,7 +201,7 @@ class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
     run_loop_->Run();
   }
 
-  scoped_ptr<VideoCaptureDevice::Names> EnumerateDevices() {
+  std::unique_ptr<VideoCaptureDevice::Names> EnumerateDevices() {
     VideoCaptureDevice::Names* names;
     EXPECT_CALL(*device_enumeration_listener_.get(),
                 OnEnumeratedDevicesCallbackPtr(_)).WillOnce(SaveArg<0>(&names));
@@ -209,17 +210,18 @@ class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
         base::Bind(&DeviceEnumerationListener::OnEnumeratedDevicesCallback,
                    device_enumeration_listener_));
     base::MessageLoop::current()->RunUntilIdle();
-    return scoped_ptr<VideoCaptureDevice::Names>(names);
+    return std::unique_ptr<VideoCaptureDevice::Names>(names);
   }
 
   const VideoCaptureFormat& last_format() const { return last_format_; }
 
-  scoped_ptr<VideoCaptureDevice::Name> GetFirstDeviceNameSupportingPixelFormat(
+  std::unique_ptr<VideoCaptureDevice::Name>
+  GetFirstDeviceNameSupportingPixelFormat(
       const VideoPixelFormat& pixel_format) {
     names_ = EnumerateDevices();
     if (names_->empty()) {
       DVLOG(1) << "No camera available.";
-      return scoped_ptr<VideoCaptureDevice::Name>();
+      return std::unique_ptr<VideoCaptureDevice::Name>();
     }
     for (const auto& names_iterator : *names_) {
       VideoCaptureFormats supported_formats;
@@ -227,7 +229,7 @@ class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
           names_iterator, &supported_formats);
       for (const auto& formats_iterator : supported_formats) {
         if (formats_iterator.pixel_format == pixel_format) {
-          return scoped_ptr<VideoCaptureDevice::Name>(
+          return std::unique_ptr<VideoCaptureDevice::Name>(
               new VideoCaptureDevice::Name(names_iterator));
         }
       }
@@ -235,7 +237,7 @@ class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
     DVLOG_IF(1, pixel_format != PIXEL_FORMAT_MAX)
         << "No camera can capture the"
         << " format: " << VideoPixelFormatToString(pixel_format);
-    return scoped_ptr<VideoCaptureDevice::Name>();
+    return std::unique_ptr<VideoCaptureDevice::Name>();
   }
 
   bool IsCaptureSizeSupported(const VideoCaptureDevice::Name& device,
@@ -256,13 +258,13 @@ class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
 #if defined(OS_WIN)
   base::win::ScopedCOMInitializer initialize_com_;
 #endif
-  scoped_ptr<VideoCaptureDevice::Names> names_;
-  scoped_ptr<base::MessageLoop> loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
-  scoped_ptr<MockClient> client_;
+  std::unique_ptr<VideoCaptureDevice::Names> names_;
+  std::unique_ptr<base::MessageLoop> loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<MockClient> client_;
   scoped_refptr<DeviceEnumerationListener> device_enumeration_listener_;
   VideoCaptureFormat last_format_;
-  scoped_ptr<VideoCaptureDeviceFactory> video_capture_device_factory_;
+  std::unique_ptr<VideoCaptureDeviceFactory> video_capture_device_factory_;
 };
 
 // Cause hangs on Windows Debug. http://crbug.com/417824
@@ -285,7 +287,7 @@ TEST_F(VideoCaptureDeviceTest, MAYBE_OpenInvalidDevice) {
 #else
   VideoCaptureDevice::Name device_name("jibberish", "jibberish");
 #endif
-  scoped_ptr<VideoCaptureDevice> device =
+  std::unique_ptr<VideoCaptureDevice> device =
       video_capture_device_factory_->Create(device_name);
 
 #if !defined(OS_MACOSX)
@@ -317,7 +319,7 @@ TEST_P(VideoCaptureDeviceTest, CaptureWithSize) {
   const int width = size.width();
   const int height = size.height();
 
-  scoped_ptr<VideoCaptureDevice> device(
+  std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->Create(names_->front()));
   ASSERT_TRUE(device);
   DVLOG(1) << names_->front().id();
@@ -351,7 +353,7 @@ TEST_F(VideoCaptureDeviceTest, MAYBE_AllocateBadSize) {
     VLOG(1) << "No camera available. Exiting test.";
     return;
   }
-  scoped_ptr<VideoCaptureDevice> device(
+  std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->Create(names_->front()));
   ASSERT_TRUE(device);
 
@@ -383,7 +385,7 @@ TEST_F(VideoCaptureDeviceTest, DISABLED_ReAllocateCamera) {
   // First, do a number of very fast device start/stops.
   for (int i = 0; i <= 5; i++) {
     ResetWithNewClient();
-    scoped_ptr<VideoCaptureDevice> device(
+    std::unique_ptr<VideoCaptureDevice> device(
         video_capture_device_factory_->Create(names_->front()));
     gfx::Size resolution;
     if (i % 2) {
@@ -406,7 +408,7 @@ TEST_F(VideoCaptureDeviceTest, DISABLED_ReAllocateCamera) {
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
 
   ResetWithNewClient();
-  scoped_ptr<VideoCaptureDevice> device(
+  std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->Create(names_->front()));
 
   device->AllocateAndStart(capture_params, std::move(client_));
@@ -423,7 +425,7 @@ TEST_F(VideoCaptureDeviceTest, DeAllocateCameraWhileRunning) {
     VLOG(1) << "No camera available. Exiting test.";
     return;
   }
-  scoped_ptr<VideoCaptureDevice> device(
+  std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->Create(names_->front()));
   ASSERT_TRUE(device);
 
@@ -444,7 +446,7 @@ TEST_F(VideoCaptureDeviceTest, DeAllocateCameraWhileRunning) {
 
 // Start the camera in 720p to capture MJPEG instead of a raw format.
 TEST_F(VideoCaptureDeviceTest, MAYBE_CaptureMjpeg) {
-  scoped_ptr<VideoCaptureDevice::Name> name =
+  std::unique_ptr<VideoCaptureDevice::Name> name =
       GetFirstDeviceNameSupportingPixelFormat(PIXEL_FORMAT_MJPEG);
   if (!name) {
     VLOG(1) << "No camera supports MJPEG format. Exiting test.";
@@ -458,7 +460,7 @@ TEST_F(VideoCaptureDeviceTest, MAYBE_CaptureMjpeg) {
     return;
   }
 #endif
-  scoped_ptr<VideoCaptureDevice> device(
+  std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->Create(*name));
   ASSERT_TRUE(device);
 
@@ -482,7 +484,7 @@ TEST_F(VideoCaptureDeviceTest, MAYBE_CaptureMjpeg) {
 TEST_F(VideoCaptureDeviceTest, GetDeviceSupportedFormats) {
   // Use PIXEL_FORMAT_MAX to iterate all device names for testing
   // GetDeviceSupportedFormats().
-  scoped_ptr<VideoCaptureDevice::Name> name =
+  std::unique_ptr<VideoCaptureDevice::Name> name =
       GetFirstDeviceNameSupportingPixelFormat(PIXEL_FORMAT_MAX);
   // Verify no camera returned for PIXEL_FORMAT_MAX. Nothing else
   // to test here
diff --git a/chromium/media/capture/video/win/video_capture_device_factory_win.cc b/chromium/media/capture/video/win/video_capture_device_factory_win.cc
index ba0904a205d..3c3bf3155fa 100644
--- a/chromium/media/capture/video/win/video_capture_device_factory_win.cc
+++ b/chromium/media/capture/video/win/video_capture_device_factory_win.cc
@@ -259,7 +259,7 @@ static void GetDeviceSupportedFormatsDirectShow(const Name& device,
     return;
   }
 
-  scoped_ptr<BYTE[]> caps(new BYTE[size]);
+  std::unique_ptr<BYTE[]> caps(new BYTE[size]);
   for (int i = 0; i < count; ++i) {
     VideoCaptureDeviceWin::ScopedMediaType media_type;
     hr = stream_config->GetStreamCaps(i, media_type.Receive(), caps.get());
@@ -376,10 +376,10 @@ VideoCaptureDeviceFactoryWin::VideoCaptureDeviceFactoryWin()
                             base::CommandLine::ForCurrentProcess()->HasSwitch(
                                 switches::kForceMediaFoundationVideoCapture)) {}
 
-scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryWin::Create(
+std::unique_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryWin::Create(
     const Name& device_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  scoped_ptr<VideoCaptureDevice> device;
+  std::unique_ptr<VideoCaptureDevice> device;
   if (device_name.capture_api_type() == Name::MEDIA_FOUNDATION) {
     DCHECK(PlatformSupportsMediaFoundation());
     device.reset(new VideoCaptureDeviceMFWin(device_name));
@@ -387,7 +387,7 @@ scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryWin::Create(
     ScopedComPtr<IMFMediaSource> source;
     if (!CreateVideoCaptureDeviceMediaFoundation(device_name.id().c_str(),
                                                  source.Receive())) {
-      return scoped_ptr<VideoCaptureDevice>();
+      return std::unique_ptr<VideoCaptureDevice>();
     }
     if (!static_cast<VideoCaptureDeviceMFWin*>(device.get())->Init(source))
       device.reset();
diff --git a/chromium/media/capture/video/win/video_capture_device_factory_win.h b/chromium/media/capture/video/win/video_capture_device_factory_win.h
index 7645cb1bc7e..e7a7665fec9 100644
--- a/chromium/media/capture/video/win/video_capture_device_factory_win.h
+++ b/chromium/media/capture/video/win/video_capture_device_factory_win.h
@@ -22,7 +22,7 @@ class MEDIA_EXPORT VideoCaptureDeviceFactoryWin
   VideoCaptureDeviceFactoryWin();
   ~VideoCaptureDeviceFactoryWin() override {}
 
-  scoped_ptr<VideoCaptureDevice> Create(
+  std::unique_ptr<VideoCaptureDevice> Create(
       const VideoCaptureDevice::Name& device_name) override;
   void GetDeviceNames(VideoCaptureDevice::Names* device_names) override;
   void GetDeviceSupportedFormats(
diff --git a/chromium/media/capture/video/win/video_capture_device_mf_win.cc b/chromium/media/capture/video/win/video_capture_device_mf_win.cc
index 94b91e03637..85ebd7e3bc6 100644
--- a/chromium/media/capture/video/win/video_capture_device_mf_win.cc
+++ b/chromium/media/capture/video/win/video_capture_device_mf_win.cc
@@ -231,7 +231,7 @@ bool VideoCaptureDeviceMFWin::Init(
 
 void VideoCaptureDeviceMFWin::AllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(CalledOnValidThread());
 
   base::AutoLock lock(lock_);
diff --git a/chromium/media/capture/video/win/video_capture_device_mf_win.h b/chromium/media/capture/video/win/video_capture_device_mf_win.h
index 78c1fb029f6..b78828e177d 100644
--- a/chromium/media/capture/video/win/video_capture_device_mf_win.h
+++ b/chromium/media/capture/video/win/video_capture_device_mf_win.h
@@ -47,8 +47,9 @@ class MEDIA_EXPORT VideoCaptureDeviceMFWin : public base::NonThreadSafe,
   bool Init(const base::win::ScopedComPtr<IMFMediaSource>& source);
 
   // VideoCaptureDevice implementation.
-  void AllocateAndStart(const VideoCaptureParams& params,
-                        scoped_ptr<VideoCaptureDevice::Client> client) override;
+  void AllocateAndStart(
+      const VideoCaptureParams& params,
+      std::unique_ptr<VideoCaptureDevice::Client> client) override;
   void StopAndDeAllocate() override;
 
   // Captured new video data.
@@ -65,7 +66,7 @@ class MEDIA_EXPORT VideoCaptureDeviceMFWin : public base::NonThreadSafe,
   scoped_refptr<MFReaderCallback> callback_;
 
   base::Lock lock_;  // Used to guard the below variables.
-  scoped_ptr<VideoCaptureDevice::Client> client_;
+  std::unique_ptr<VideoCaptureDevice::Client> client_;
   base::win::ScopedComPtr<IMFSourceReader> reader_;
   VideoCaptureFormat capture_format_;
   bool capture_;
diff --git a/chromium/media/capture/video/win/video_capture_device_win.cc b/chromium/media/capture/video/win/video_capture_device_win.cc
index 53a47dd5f30..b6018cb4202 100644
--- a/chromium/media/capture/video/win/video_capture_device_win.cc
+++ b/chromium/media/capture/video/win/video_capture_device_win.cc
@@ -330,7 +330,7 @@ bool VideoCaptureDeviceWin::Init() {
 
 void VideoCaptureDeviceWin::AllocateAndStart(
     const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
+    std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kIdle)
     return;
@@ -361,7 +361,7 @@ void VideoCaptureDeviceWin::AllocateAndStart(
     return;
   }
 
-  scoped_ptr<BYTE[]> caps(new BYTE[size]);
+  std::unique_ptr<BYTE[]> caps(new BYTE[size]);
   ScopedMediaType media_type;
 
   // Get the windows capability from the capture device.
@@ -480,7 +480,7 @@ bool VideoCaptureDeviceWin::CreateCapabilityMap() {
     return false;
   }
 
-  scoped_ptr<BYTE[]> caps(new BYTE[size]);
+  std::unique_ptr<BYTE[]> caps(new BYTE[size]);
   for (int stream_index = 0; stream_index < count; ++stream_index) {
     ScopedMediaType media_type;
     hr = stream_config->GetStreamCaps(stream_index, media_type.Receive(),
diff --git a/chromium/media/capture/video/win/video_capture_device_win.h b/chromium/media/capture/video/win/video_capture_device_win.h
index 1e856a26d58..0db9c85f76f 100644
--- a/chromium/media/capture/video/win/video_capture_device_win.h
+++ b/chromium/media/capture/video/win/video_capture_device_win.h
@@ -70,8 +70,9 @@ class VideoCaptureDeviceWin : public VideoCaptureDevice,
   bool Init();
 
   // VideoCaptureDevice implementation.
-  void AllocateAndStart(const VideoCaptureParams& params,
-                        scoped_ptr<VideoCaptureDevice::Client> client) override;
+  void AllocateAndStart(
+      const VideoCaptureParams& params,
+      std::unique_ptr<VideoCaptureDevice::Client> client) override;
   void StopAndDeAllocate() override;
 
  private:
@@ -94,7 +95,7 @@ class VideoCaptureDeviceWin : public VideoCaptureDevice,
 
   const Name device_name_;
   InternalState state_;
-  scoped_ptr<VideoCaptureDevice::Client> client_;
+  std::unique_ptr<VideoCaptureDevice::Client> client_;
 
   base::win::ScopedComPtr<IBaseFilter> capture_filter_;