BASELINE: Update Chromium to 64.0.3282.139

Change-Id: I1cae68fe9c94ff7608b26b8382fc19862cdb293a
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

43 files changed, 405 insertions, 279 deletions

diff --git a/chromium/media/capture/video/DEPS b/chromium/media/capture/video/DEPS
index 5dafd17cc6c..77681e1b65e 100644
--- a/chromium/media/capture/video/DEPS
+++ b/chromium/media/capture/video/DEPS
@@ -1,4 +1,5 @@
 include_rules = [
+  "+chromeos/dbus",
   "+mojo/public/cpp",
   "+third_party/libyuv",
 ]
diff --git a/chromium/media/capture/video/chromeos/DEPS b/chromium/media/capture/video/chromeos/DEPS
index fb8e78a6f99..fe2df0dba85 100644
--- a/chromium/media/capture/video/chromeos/DEPS
+++ b/chromium/media/capture/video/chromeos/DEPS
@@ -1,4 +1,5 @@
 include_rules = [
+  "+chromeos/dbus",
   "+mojo/edk/embedder",
   "+third_party/libsync",
 ]
diff --git a/chromium/media/capture/video/chromeos/camera_buffer_factory.cc b/chromium/media/capture/video/chromeos/camera_buffer_factory.cc
index fe379833c73..2816194b45d 100644
--- a/chromium/media/capture/video/chromeos/camera_buffer_factory.cc
+++ b/chromium/media/capture/video/chromeos/camera_buffer_factory.cc
@@ -8,9 +8,9 @@
 
 namespace media {
 
-CameraBufferFactory::CameraBufferFactory() {}
+CameraBufferFactory::CameraBufferFactory() = default;
 
-CameraBufferFactory::~CameraBufferFactory() {}
+CameraBufferFactory::~CameraBufferFactory() = default;
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 CameraBufferFactory::CreateGpuMemoryBuffer(const gfx::Size& size,
diff --git a/chromium/media/capture/video/chromeos/camera_device_context.cc b/chromium/media/capture/video/chromeos/camera_device_context.cc
index 36a9bd1977d..15cb775e3d2 100644
--- a/chromium/media/capture/video/chromeos/camera_device_context.cc
+++ b/chromium/media/capture/video/chromeos/camera_device_context.cc
@@ -10,9 +10,10 @@ CameraDeviceContext::CameraDeviceContext(
     std::unique_ptr<VideoCaptureDevice::Client> client)
     : state_(State::kStopped), rotation_(0), client_(std::move(client)) {
   DCHECK(client_);
+  DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
-CameraDeviceContext::~CameraDeviceContext() {}
+CameraDeviceContext::~CameraDeviceContext() = default;
 
 void CameraDeviceContext::SetState(State state) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
diff --git a/chromium/media/capture/video/chromeos/camera_device_delegate.cc b/chromium/media/capture/video/chromeos/camera_device_delegate.cc
index 0d78fb56be4..68550c99b36 100644
--- a/chromium/media/capture/video/chromeos/camera_device_delegate.cc
+++ b/chromium/media/capture/video/chromeos/camera_device_delegate.cc
@@ -20,9 +20,9 @@
 
 namespace media {
 
-StreamCaptureInterface::Plane::Plane() {}
+StreamCaptureInterface::Plane::Plane() = default;
 
-StreamCaptureInterface::Plane::~Plane() {}
+StreamCaptureInterface::Plane::~Plane() = default;
 
 class CameraDeviceDelegate::StreamCaptureInterfaceImpl final
     : public StreamCaptureInterface {
@@ -68,15 +68,15 @@ CameraDeviceDelegate::CameraDeviceDelegate(
       ipc_task_runner_(std::move(ipc_task_runner)),
       weak_ptr_factory_(this) {}
 
-CameraDeviceDelegate::~CameraDeviceDelegate() {}
+CameraDeviceDelegate::~CameraDeviceDelegate() = default;
 
 void CameraDeviceDelegate::AllocateAndStart(
     const VideoCaptureParams& params,
-    std::unique_ptr<VideoCaptureDevice::Client> client) {
+    CameraDeviceContext* device_context) {
   DCHECK(ipc_task_runner_->BelongsToCurrentThread());
 
   chrome_capture_params_ = params;
-  device_context_.reset(new CameraDeviceContext(std::move(client)));
+  device_context_ = device_context;
   device_context_->SetState(CameraDeviceContext::State::kStarting);
 
   // We need to get the static camera metadata of the camera device first.
@@ -175,7 +175,7 @@ void CameraDeviceDelegate::OnClosed(int32_t result) {
                                  std::string(strerror(result)));
   }
   ResetMojoInterface();
-  device_context_.reset();
+  device_context_ = nullptr;
   std::move(device_close_callback_).Run();
 }
 
@@ -246,7 +246,7 @@ void CameraDeviceDelegate::Initialize() {
   stream_buffer_manager_ = base::MakeUnique<StreamBufferManager>(
       std::move(callback_ops_request),
       base::MakeUnique<StreamCaptureInterfaceImpl>(GetWeakPtr()),
-      device_context_.get(), base::MakeUnique<CameraBufferFactory>(),
+      device_context_, base::MakeUnique<CameraBufferFactory>(),
       ipc_task_runner_);
   device_ops_->Initialize(
       std::move(callback_ops_ptr),
diff --git a/chromium/media/capture/video/chromeos/camera_device_delegate.h b/chromium/media/capture/video/chromeos/camera_device_delegate.h
index e69727aa34d..b1a74a48a53 100644
--- a/chromium/media/capture/video/chromeos/camera_device_delegate.h
+++ b/chromium/media/capture/video/chromeos/camera_device_delegate.h
@@ -64,7 +64,7 @@ class CAPTURE_EXPORT CameraDeviceDelegate final {
 
   // Delegation methods for the VideoCaptureDevice interface.
   void AllocateAndStart(const VideoCaptureParams& params,
-                        std::unique_ptr<VideoCaptureDevice::Client> client);
+                        CameraDeviceContext* device_context);
   void StopAndDeAllocate(base::Closure device_close_callback);
   void TakePhoto(VideoCaptureDevice::TakePhotoCallback callback);
   void GetPhotoState(VideoCaptureDevice::GetPhotoStateCallback callback);
@@ -147,7 +147,7 @@ class CAPTURE_EXPORT CameraDeviceDelegate final {
 
   VideoCaptureParams chrome_capture_params_;
 
-  std::unique_ptr<CameraDeviceContext> device_context_;
+  CameraDeviceContext* device_context_;
 
   std::unique_ptr<StreamBufferManager> stream_buffer_manager_;
 
diff --git a/chromium/media/capture/video/chromeos/camera_device_delegate_unittest.cc b/chromium/media/capture/video/chromeos/camera_device_delegate_unittest.cc
index ad815122b9f..2a9a1c44d83 100644
--- a/chromium/media/capture/video/chromeos/camera_device_delegate_unittest.cc
+++ b/chromium/media/capture/video/chromeos/camera_device_delegate_unittest.cc
@@ -37,9 +37,9 @@ namespace {
 
 class MockCameraDevice : public arc::mojom::Camera3DeviceOps {
  public:
-  MockCameraDevice() {}
+  MockCameraDevice() = default;
 
-  ~MockCameraDevice() {}
+  ~MockCameraDevice() = default;
 
   void Initialize(arc::mojom::Camera3CallbackOpsPtr callback_ops,
                   InitializeCallback callback) override {
@@ -134,8 +134,6 @@ class CameraDeviceDelegateTest : public ::testing::Test {
         new CameraHalDelegate(hal_delegate_thread_.task_runner());
     camera_hal_delegate_->SetCameraModule(
         mock_camera_module_.GetInterfacePtrInfo());
-
-    ResetCaptureClient();
   }
 
   void TearDown() override {
@@ -345,9 +343,13 @@ class CameraDeviceDelegateTest : public ::testing::Test {
     EXPECT_EQ(CameraDeviceContext::State::kStopped, GetState());
   }
 
-  void ResetCaptureClient() {
-    mock_client_ =
+  unittest_internal::MockVideoCaptureClient* ResetDeviceContext() {
+    auto mock_client =
         base::MakeUnique<unittest_internal::MockVideoCaptureClient>();
+    auto* client_ptr = mock_client.get();
+    device_context_ =
+        base::MakeUnique<CameraDeviceContext>(std::move(mock_client));
+    return client_ptr;
   }
 
   void ResetDevice() {
@@ -392,7 +394,7 @@ class CameraDeviceDelegateTest : public ::testing::Test {
 
   base::Thread device_delegate_thread_;
 
-  std::unique_ptr<VideoCaptureDevice::Client> mock_client_;
+  std::unique_ptr<CameraDeviceContext> device_context_;
 
  private:
   base::test::ScopedTaskEnvironment scoped_task_environment_;
@@ -409,9 +411,7 @@ TEST_F(CameraDeviceDelegateTest, AllocateCaptureAndStop) {
   VideoCaptureParams params;
   params.requested_format = kDefaultCaptureFormat;
 
-  auto* mock_client =
-      reinterpret_cast<unittest_internal::MockVideoCaptureClient*>(
-          mock_client_.get());
+  auto* mock_client = ResetDeviceContext();
   mock_client->SetFrameCb(BindToCurrentLoop(base::BindOnce(
       &CameraDeviceDelegateTest::QuitRunLoop, base::Unretained(this))));
   mock_client->SetQuitCb(BindToCurrentLoop(base::BindOnce(
@@ -422,7 +422,7 @@ TEST_F(CameraDeviceDelegateTest, AllocateCaptureAndStop) {
   device_delegate_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&CameraDeviceDelegate::AllocateAndStart,
                             camera_device_delegate_->GetWeakPtr(), params,
-                            base::Passed(&mock_client_)));
+                            base::Unretained(device_context_.get())));
 
   // Wait until a frame is received.  MockVideoCaptureClient calls QuitRunLoop()
   // to stop the run loop.
@@ -444,9 +444,7 @@ TEST_F(CameraDeviceDelegateTest, StopAfterInitialized) {
   VideoCaptureParams params;
   params.requested_format = kDefaultCaptureFormat;
 
-  auto* mock_client =
-      reinterpret_cast<unittest_internal::MockVideoCaptureClient*>(
-          mock_client_.get());
+  auto* mock_client = ResetDeviceContext();
   mock_client->SetQuitCb(BindToCurrentLoop(base::BindOnce(
       &CameraDeviceDelegateTest::QuitRunLoop, base::Unretained(this))));
   SetUpExpectationUntilInitialized();
@@ -454,7 +452,7 @@ TEST_F(CameraDeviceDelegateTest, StopAfterInitialized) {
   device_delegate_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&CameraDeviceDelegate::AllocateAndStart,
                             camera_device_delegate_->GetWeakPtr(), params,
-                            base::Passed(&mock_client_)));
+                            base::Unretained(device_context_.get())));
 
   EXPECT_CALL(mock_camera_device_, DoConfigureStreams(_, _))
       .Times(1)
@@ -488,9 +486,7 @@ TEST_F(CameraDeviceDelegateTest, StopAfterStreamConfigured) {
   VideoCaptureParams params;
   params.requested_format = kDefaultCaptureFormat;
 
-  auto* mock_client =
-      reinterpret_cast<unittest_internal::MockVideoCaptureClient*>(
-          mock_client_.get());
+  auto* mock_client = ResetDeviceContext();
   mock_client->SetQuitCb(BindToCurrentLoop(base::BindOnce(
       &CameraDeviceDelegateTest::QuitRunLoop, base::Unretained(this))));
   SetUpExpectationUntilStreamConfigured();
@@ -498,7 +494,7 @@ TEST_F(CameraDeviceDelegateTest, StopAfterStreamConfigured) {
   device_delegate_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&CameraDeviceDelegate::AllocateAndStart,
                             camera_device_delegate_->GetWeakPtr(), params,
-                            base::Passed(&mock_client_)));
+                            base::Unretained(device_context_.get())));
 
   EXPECT_CALL(mock_camera_device_, DoConstructDefaultRequestSettings(_, _))
       .Times(1)
@@ -530,9 +526,7 @@ TEST_F(CameraDeviceDelegateTest, FailToOpenDevice) {
   VideoCaptureParams params;
   params.requested_format = kDefaultCaptureFormat;
 
-  auto* mock_client =
-      reinterpret_cast<unittest_internal::MockVideoCaptureClient*>(
-          mock_client_.get());
+  auto* mock_client = ResetDeviceContext();
 
   auto stop_on_error = [&]() {
     device_delegate_thread_.task_runner()->PostTask(
@@ -565,7 +559,7 @@ TEST_F(CameraDeviceDelegateTest, FailToOpenDevice) {
   device_delegate_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&CameraDeviceDelegate::AllocateAndStart,
                             camera_device_delegate_->GetWeakPtr(), params,
-                            base::Passed(&mock_client_)));
+                            base::Unretained(device_context_.get())));
 
   // Wait unitl |camera_device_delegate_->StopAndDeAllocate| calls the
   // QuitRunLoop callback.
diff --git a/chromium/media/capture/video/chromeos/camera_hal_delegate.cc b/chromium/media/capture/video/chromeos/camera_hal_delegate.cc
index b31e0bfcc70..fcb63be0057 100644
--- a/chromium/media/capture/video/chromeos/camera_hal_delegate.cc
+++ b/chromium/media/capture/video/chromeos/camera_hal_delegate.cc
@@ -57,7 +57,7 @@ CameraHalDelegate::CameraHalDelegate(
   DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
-CameraHalDelegate::~CameraHalDelegate() {}
+CameraHalDelegate::~CameraHalDelegate() = default;
 
 void CameraHalDelegate::RegisterCameraClient() {
   CameraHalDispatcherImpl::GetInstance()->AddClientObserver(
diff --git a/chromium/media/capture/video/chromeos/camera_hal_dispatcher_impl.cc b/chromium/media/capture/video/chromeos/camera_hal_dispatcher_impl.cc
index 06bdfb3f71f..4c5f17d06cb 100644
--- a/chromium/media/capture/video/chromeos/camera_hal_dispatcher_impl.cc
+++ b/chromium/media/capture/video/chromeos/camera_hal_dispatcher_impl.cc
@@ -9,6 +9,8 @@
 #include <poll.h>
 #include <sys/uio.h>
 
+#include <vector>
+
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/posix/eintr_wrapper.h"
@@ -20,7 +22,6 @@
 #include "mojo/edk/embedder/outgoing_broker_client_invitation.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_channel_utils_posix.h"
-#include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 
 namespace media {
@@ -87,7 +88,7 @@ class MojoCameraClientObserver : public CameraClientObserver {
 
 }  // namespace
 
-CameraClientObserver::~CameraClientObserver() {}
+CameraClientObserver::~CameraClientObserver() = default;
 
 // static
 CameraHalDispatcherImpl* CameraHalDispatcherImpl::GetInstance() {
@@ -265,8 +266,7 @@ void CameraHalDispatcherImpl::StartServiceLoop(
     }
 
     mojo::edk::ScopedPlatformHandle accepted_fd;
-    if (mojo::edk::ServerAcceptConnection(proxy_fd_.get(), &accepted_fd,
-                                          false) &&
+    if (mojo::edk::ServerAcceptConnection(proxy_fd_, &accepted_fd, false) &&
         accepted_fd.is_valid()) {
       VLOG(1) << "Accepted a connection";
       // Hardcode pid 0 since it is unused in mojo.
@@ -282,13 +282,12 @@ void CameraHalDispatcherImpl::StartServiceLoop(
           mojo::edk::ConnectionParams(mojo::edk::TransportProtocol::kLegacy,
                                       channel_pair.PassServerHandle()));
 
-      mojo::edk::ScopedPlatformHandleVectorPtr handles(
-          new mojo::edk::PlatformHandleVector{
-              channel_pair.PassClientHandle().release()});
+      std::vector<mojo::edk::ScopedPlatformHandle> handles;
+      handles.emplace_back(channel_pair.PassClientHandle());
 
       struct iovec iov = {const_cast<char*>(token.c_str()), token.length()};
       ssize_t result = mojo::edk::PlatformChannelSendmsgWithHandles(
-          accepted_fd.get(), &iov, 1, handles->data(), handles->size());
+          accepted_fd, &iov, 1, handles);
       if (result == -1) {
         PLOG(ERROR) << "sendmsg()";
       } else {
diff --git a/chromium/media/capture/video/chromeos/camera_hal_dispatcher_impl_unittest.cc b/chromium/media/capture/video/chromeos/camera_hal_dispatcher_impl_unittest.cc
index 8af8fc2d79d..d14966cbe13 100644
--- a/chromium/media/capture/video/chromeos/camera_hal_dispatcher_impl_unittest.cc
+++ b/chromium/media/capture/video/chromeos/camera_hal_dispatcher_impl_unittest.cc
@@ -25,7 +25,7 @@ class MockCameraHalServer : public arc::mojom::CameraHalServer {
  public:
   MockCameraHalServer() : binding_(this) {}
 
-  ~MockCameraHalServer() {}
+  ~MockCameraHalServer() = default;
 
   void CreateChannel(
       arc::mojom::CameraModuleRequest camera_module_request) override {
@@ -51,7 +51,7 @@ class MockCameraHalClient : public arc::mojom::CameraHalClient {
  public:
   MockCameraHalClient() : binding_(this) {}
 
-  ~MockCameraHalClient() {}
+  ~MockCameraHalClient() = default;
 
   void SetUpChannel(arc::mojom::CameraModulePtr camera_module_ptr) override {
     DoSetUpChannel(camera_module_ptr);
@@ -76,9 +76,9 @@ class MockCameraHalClient : public arc::mojom::CameraHalClient {
 
 class CameraHalDispatcherImplTest : public ::testing::Test {
  public:
-  CameraHalDispatcherImplTest() {}
+  CameraHalDispatcherImplTest() = default;
 
-  ~CameraHalDispatcherImplTest() override {}
+  ~CameraHalDispatcherImplTest() override = default;
 
   void SetUp() override {
     dispatcher_ = new CameraHalDispatcherImpl();
diff --git a/chromium/media/capture/video/chromeos/local_gpu_memory_buffer_manager.cc b/chromium/media/capture/video/chromeos/local_gpu_memory_buffer_manager.cc
index f224fe4ea9d..4355125336b 100644
--- a/chromium/media/capture/video/chromeos/local_gpu_memory_buffer_manager.cc
+++ b/chromium/media/capture/video/chromeos/local_gpu_memory_buffer_manager.cc
@@ -146,7 +146,7 @@ class GpuMemoryBufferImplGbm : public gfx::GpuMemoryBuffer {
     return gbm_bo_get_plane_stride(buffer_object_, plane);
   }
 
-  void SetColorSpaceForScanout(const gfx::ColorSpace& color_space) override {}
+  void SetColorSpace(const gfx::ColorSpace& color_space) override {}
 
   gfx::GpuMemoryBufferId GetId() const override { return handle_.id; }
 
diff --git a/chromium/media/capture/video/chromeos/mock_gpu_memory_buffer_manager.cc b/chromium/media/capture/video/chromeos/mock_gpu_memory_buffer_manager.cc
index 06f9d80a01b..3fea2cccb75 100644
--- a/chromium/media/capture/video/chromeos/mock_gpu_memory_buffer_manager.cc
+++ b/chromium/media/capture/video/chromeos/mock_gpu_memory_buffer_manager.cc
@@ -11,13 +11,13 @@ using ::testing::Return;
 namespace media {
 namespace unittest_internal {
 
-MockGpuMemoryBuffer::MockGpuMemoryBuffer() {}
+MockGpuMemoryBuffer::MockGpuMemoryBuffer() = default;
 
-MockGpuMemoryBuffer::~MockGpuMemoryBuffer() {}
+MockGpuMemoryBuffer::~MockGpuMemoryBuffer() = default;
 
-MockGpuMemoryBufferManager::MockGpuMemoryBufferManager() {}
+MockGpuMemoryBufferManager::MockGpuMemoryBufferManager() = default;
 
-MockGpuMemoryBufferManager::~MockGpuMemoryBufferManager() {}
+MockGpuMemoryBufferManager::~MockGpuMemoryBufferManager() = default;
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 MockGpuMemoryBufferManager::ReturnValidBuffer(
diff --git a/chromium/media/capture/video/chromeos/mock_gpu_memory_buffer_manager.h b/chromium/media/capture/video/chromeos/mock_gpu_memory_buffer_manager.h
index 6b5c7228f21..c03671fe777 100644
--- a/chromium/media/capture/video/chromeos/mock_gpu_memory_buffer_manager.h
+++ b/chromium/media/capture/video/chromeos/mock_gpu_memory_buffer_manager.h
@@ -31,8 +31,7 @@ class MockGpuMemoryBuffer : public gfx::GpuMemoryBuffer {
 
   MOCK_CONST_METHOD1(stride, int(size_t plane));
 
-  MOCK_METHOD1(SetColorSpaceForScanout,
-               void(const gfx::ColorSpace& color_space));
+  MOCK_METHOD1(SetColorSpace, void(const gfx::ColorSpace& color_space));
 
   MOCK_CONST_METHOD0(GetId, gfx::GpuMemoryBufferId());
 
diff --git a/chromium/media/capture/video/chromeos/stream_buffer_manager.cc b/chromium/media/capture/video/chromeos/stream_buffer_manager.cc
index 7193cc3e648..8bba363f807 100644
--- a/chromium/media/capture/video/chromeos/stream_buffer_manager.cc
+++ b/chromium/media/capture/video/chromeos/stream_buffer_manager.cc
@@ -40,7 +40,9 @@ StreamBufferManager::~StreamBufferManager() {
   DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   if (stream_context_) {
     for (const auto& buf : stream_context_->buffers) {
-      buf->Unmap();
+      if (buf) {
+        buf->Unmap();
+      }
     }
   }
 }
@@ -496,13 +498,13 @@ void StreamBufferManager::SubmitCaptureResult(uint32_t frame_number) {
   RegisterBuffer();
 }
 
-StreamBufferManager::StreamContext::StreamContext() {}
+StreamBufferManager::StreamContext::StreamContext() = default;
 
-StreamBufferManager::StreamContext::~StreamContext() {}
+StreamBufferManager::StreamContext::~StreamContext() = default;
 
 StreamBufferManager::CaptureResult::CaptureResult()
     : metadata(arc::mojom::CameraMetadata::New()) {}
 
-StreamBufferManager::CaptureResult::~CaptureResult() {}
+StreamBufferManager::CaptureResult::~CaptureResult() = default;
 
 }  // namespace media
diff --git a/chromium/media/capture/video/chromeos/video_capture_device_arc_chromeos.cc b/chromium/media/capture/video/chromeos/video_capture_device_arc_chromeos.cc
index f23d025f93c..557df723405 100644
--- a/chromium/media/capture/video/chromeos/video_capture_device_arc_chromeos.cc
+++ b/chromium/media/capture/video/chromeos/video_capture_device_arc_chromeos.cc
@@ -11,6 +11,9 @@
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "media/base/bind_to_current_loop.h"
+#include "media/capture/video/chromeos/camera_device_context.h"
 #include "media/capture/video/chromeos/camera_device_delegate.h"
 #include "media/capture/video/chromeos/camera_hal_delegate.h"
 #include "ui/display/display.h"
@@ -37,12 +40,18 @@ VideoCaptureDeviceArcChromeOS::VideoCaptureDeviceArcChromeOS(
       // We don't want to rotate the frame even if the device rotates.
       rotates_with_device_(lens_facing_ !=
                            VideoFacingMode::MEDIA_VIDEO_FACING_NONE),
-      rotation_(0) {}
+      rotation_(0),
+      weak_ptr_factory_(this) {
+  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(
+      this);
+}
 
 VideoCaptureDeviceArcChromeOS::~VideoCaptureDeviceArcChromeOS() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DCHECK(!camera_device_ipc_thread_.IsRunning());
   screen_observer_delegate_->RemoveObserver();
+  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(
+      this);
 }
 
 // VideoCaptureDevice implementation.
@@ -58,16 +67,12 @@ void VideoCaptureDeviceArcChromeOS::AllocateAndStart(
     client->OnError(FROM_HERE, error_msg);
     return;
   }
+  capture_params_ = params;
+  device_context_ = base::MakeUnique<CameraDeviceContext>(std::move(client));
   camera_device_delegate_ = base::MakeUnique<CameraDeviceDelegate>(
       device_descriptor_, camera_hal_delegate_,
       camera_device_ipc_thread_.task_runner());
-  camera_device_ipc_thread_.task_runner()->PostTask(
-      FROM_HERE, base::Bind(&CameraDeviceDelegate::AllocateAndStart,
-                            camera_device_delegate_->GetWeakPtr(), params,
-                            base::Passed(&client)));
-  camera_device_ipc_thread_.task_runner()->PostTask(
-      FROM_HERE, base::Bind(&CameraDeviceDelegate::SetRotation,
-                            camera_device_delegate_->GetWeakPtr(), rotation_));
+  OpenDevice();
 }
 
 void VideoCaptureDeviceArcChromeOS::StopAndDeAllocate() {
@@ -76,27 +81,10 @@ void VideoCaptureDeviceArcChromeOS::StopAndDeAllocate() {
   if (!camera_device_delegate_) {
     return;
   }
-
-  // We do our best to allow the camera HAL cleanly shut down the device.  In
-  // general we don't trust the camera HAL so if the device does not close in
-  // time we simply terminate the Mojo channel by resetting
-  // |camera_device_delegate_|.
-  base::WaitableEvent device_closed(
-      base::WaitableEvent::ResetPolicy::MANUAL,
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
-  camera_device_ipc_thread_.task_runner()->PostTask(
-      FROM_HERE, base::Bind(&CameraDeviceDelegate::StopAndDeAllocate,
-                            camera_device_delegate_->GetWeakPtr(),
-                            base::Bind(
-                                [](base::WaitableEvent* device_closed) {
-                                  device_closed->Signal();
-                                },
-                                base::Unretained(&device_closed))));
-  base::TimeDelta kWaitTimeoutSecs = base::TimeDelta::FromSeconds(3);
-  device_closed.TimedWait(kWaitTimeoutSecs);
-
+  CloseDevice(base::Closure());
   camera_device_ipc_thread_.Stop();
   camera_device_delegate_.reset();
+  device_context_.reset();
 }
 
 void VideoCaptureDeviceArcChromeOS::TakePhoto(TakePhotoCallback callback) {
@@ -127,6 +115,68 @@ void VideoCaptureDeviceArcChromeOS::SetPhotoOptions(
                             base::Passed(&settings), base::Passed(&callback)));
 }
 
+void VideoCaptureDeviceArcChromeOS::SuspendImminent(
+    power_manager::SuspendImminent::Reason reason) {
+  capture_task_runner_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&VideoCaptureDeviceArcChromeOS::CloseDevice,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     BindToCurrentLoop(chromeos::DBusThreadManager::Get()
+                                           ->GetPowerManagerClient()
+                                           ->GetSuspendReadinessCallback())));
+}
+
+void VideoCaptureDeviceArcChromeOS::SuspendDone(
+    const base::TimeDelta& sleep_duration) {
+  capture_task_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&VideoCaptureDeviceArcChromeOS::OpenDevice,
+                                weak_ptr_factory_.GetWeakPtr()));
+}
+
+void VideoCaptureDeviceArcChromeOS::OpenDevice() {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+
+  // It's safe to pass unretained |device_context_| here since
+  // VideoCaptureDeviceArcChromeOS owns |camera_device_delegate_| and makes
+  // sure |device_context_| outlives |camera_device_delegate_|.
+  camera_device_ipc_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&CameraDeviceDelegate::AllocateAndStart,
+                 camera_device_delegate_->GetWeakPtr(), capture_params_,
+                 base::Unretained(device_context_.get())));
+  camera_device_ipc_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&CameraDeviceDelegate::SetRotation,
+                            camera_device_delegate_->GetWeakPtr(), rotation_));
+}
+
+void VideoCaptureDeviceArcChromeOS::CloseDevice(base::Closure callback) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+
+  if (!camera_device_delegate_) {
+    return;
+  }
+  // We do our best to allow the camera HAL cleanly shut down the device.  In
+  // general we don't trust the camera HAL so if the device does not close in
+  // time we simply terminate the Mojo channel by resetting
+  // |camera_device_delegate_|.
+  base::WaitableEvent device_closed(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  camera_device_ipc_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&CameraDeviceDelegate::StopAndDeAllocate,
+                            camera_device_delegate_->GetWeakPtr(),
+                            base::Bind(
+                                [](base::WaitableEvent* device_closed) {
+                                  device_closed->Signal();
+                                },
+                                base::Unretained(&device_closed))));
+  base::TimeDelta kWaitTimeoutSecs = base::TimeDelta::FromSeconds(3);
+  device_closed.TimedWait(kWaitTimeoutSecs);
+  if (callback) {
+    callback.Run();
+  }
+}
+
 void VideoCaptureDeviceArcChromeOS::SetDisplayRotation(
     const display::Display& display) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
diff --git a/chromium/media/capture/video/chromeos/video_capture_device_arc_chromeos.h b/chromium/media/capture/video/chromeos/video_capture_device_arc_chromeos.h
index 357baf2a437..d56dcdbf456 100644
--- a/chromium/media/capture/video/chromeos/video_capture_device_arc_chromeos.h
+++ b/chromium/media/capture/video/chromeos/video_capture_device_arc_chromeos.h
@@ -8,7 +8,9 @@
 #include <memory>
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
+#include "chromeos/dbus/power_manager_client.h"
 #include "media/capture/video/chromeos/display_rotation_observer.h"
 #include "media/capture/video/chromeos/mojo/arc_camera3.mojom.h"
 #include "media/capture/video/video_capture_device.h"
@@ -24,12 +26,14 @@ class Display;
 namespace media {
 
 class CameraHalDelegate;
+class CameraDeviceContext;
 class CameraDeviceDelegate;
 
 // Implementation of VideoCaptureDevice for ChromeOS with ARC++ camera HALv3.
 class CAPTURE_EXPORT VideoCaptureDeviceArcChromeOS final
     : public VideoCaptureDevice,
-      public DisplayRotationObserver {
+      public DisplayRotationObserver,
+      public chromeos::PowerManagerClient::Observer {
  public:
   VideoCaptureDeviceArcChromeOS(
       scoped_refptr<base::SingleThreadTaskRunner>
@@ -48,7 +52,15 @@ class CAPTURE_EXPORT VideoCaptureDeviceArcChromeOS final
   void SetPhotoOptions(mojom::PhotoSettingsPtr settings,
                        SetPhotoOptionsCallback callback) final;
 
+  // chromeos::PowerManagerClient::Observer callbacks for system suspend and
+  // resume events.
+  void SuspendImminent(power_manager::SuspendImminent::Reason reason) final;
+  void SuspendDone(const base::TimeDelta& sleep_duration) final;
+
  private:
+  void OpenDevice();
+  void CloseDevice(base::Closure callback);
+
   // DisplayRotationDelegate implementation.
   void SetDisplayRotation(const display::Display& display) final;
   void SetRotation(int rotation);
@@ -69,6 +81,11 @@ class CAPTURE_EXPORT VideoCaptureDeviceArcChromeOS final
   // |capture_task_runner_|.
   base::Thread camera_device_ipc_thread_;
 
+  VideoCaptureParams capture_params_;
+  // |device_context_| is created and owned by VideoCaptureDeviceArcChromeOS
+  // and is only accessed by |camera_device_delegate_|.
+  std::unique_ptr<CameraDeviceContext> device_context_;
+
   // Internal delegate doing the actual capture setting, buffer allocation and
   // circulation with the camera HAL. Created in AllocateAndStart and deleted in
   // StopAndDeAllocate on |capture_task_runner_|.  All methods of
@@ -82,6 +99,8 @@ class CAPTURE_EXPORT VideoCaptureDeviceArcChromeOS final
   const bool rotates_with_device_;
   int rotation_;
 
+  base::WeakPtrFactory<VideoCaptureDeviceArcChromeOS> weak_ptr_factory_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoCaptureDeviceArcChromeOS);
 };
 
diff --git a/chromium/media/capture/video/fake_video_capture_device.cc b/chromium/media/capture/video/fake_video_capture_device.cc
index 800cdd034a9..6662752d69b 100644
--- a/chromium/media/capture/video/fake_video_capture_device.cc
+++ b/chromium/media/capture/video/fake_video_capture_device.cc
@@ -106,7 +106,7 @@ class FrameDeliverer {
  public:
   FrameDeliverer(std::unique_ptr<PacmanFramePainter> frame_painter)
       : frame_painter_(std::move(frame_painter)) {}
-  virtual ~FrameDeliverer() {}
+  virtual ~FrameDeliverer() = default;
   virtual void Initialize(VideoPixelFormat pixel_format,
                           std::unique_ptr<VideoCaptureDevice::Client> client,
                           const FakeDeviceState* device_state) {
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 dee4cab8788..3abc9a1c86d 100644
--- a/chromium/media/capture/video/fake_video_capture_device_unittest.cc
+++ b/chromium/media/capture/video/fake_video_capture_device_unittest.cc
@@ -55,7 +55,7 @@ class StubBufferHandleProvider
   StubBufferHandleProvider(size_t mapped_size, uint8_t* data)
       : mapped_size_(mapped_size), data_(data) {}
 
-  ~StubBufferHandleProvider() override {}
+  ~StubBufferHandleProvider() override = default;
 
   mojo::ScopedSharedBufferHandle GetHandleForInterProcessTransit(
       bool read_only) override {
@@ -185,7 +185,7 @@ class ImageCaptureClient : public base::RefCounted<ImageCaptureClient> {
 
  private:
   friend class base::RefCounted<ImageCaptureClient>;
-  virtual ~ImageCaptureClient() {}
+  virtual ~ImageCaptureClient() = default;
 
   mojom::PhotoStatePtr state_;
 };
diff --git a/chromium/media/capture/video/file_video_capture_device.cc b/chromium/media/capture/video/file_video_capture_device.cc
index bd5f0799f0b..cacd86879d1 100644
--- a/chromium/media/capture/video/file_video_capture_device.cc
+++ b/chromium/media/capture/video/file_video_capture_device.cc
@@ -164,12 +164,12 @@ VideoFileParser::VideoFileParser(const base::FilePath& file_path)
       current_byte_index_(0),
       first_frame_byte_index_(0) {}
 
-VideoFileParser::~VideoFileParser() {}
+VideoFileParser::~VideoFileParser() = default;
 
 Y4mFileParser::Y4mFileParser(const base::FilePath& file_path)
     : VideoFileParser(file_path) {}
 
-Y4mFileParser::~Y4mFileParser() {}
+Y4mFileParser::~Y4mFileParser() = default;
 
 bool Y4mFileParser::Initialize(media::VideoCaptureFormat* capture_format) {
   file_.reset(new base::File(file_path_,
@@ -218,7 +218,7 @@ const uint8_t* Y4mFileParser::GetNextFrame(int* frame_size) {
 MjpegFileParser::MjpegFileParser(const base::FilePath& file_path)
     : VideoFileParser(file_path) {}
 
-MjpegFileParser::~MjpegFileParser() {}
+MjpegFileParser::~MjpegFileParser() = default;
 
 bool MjpegFileParser::Initialize(media::VideoCaptureFormat* capture_format) {
   mapped_file_.reset(new base::MemoryMappedFile());
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 78ad6c86831..ea361b243ef 100644
--- a/chromium/media/capture/video/file_video_capture_device_factory.cc
+++ b/chromium/media/capture/video/file_video_capture_device_factory.cc
@@ -29,7 +29,7 @@ base::FilePath GetFilePathFromCommandLine() {
 std::unique_ptr<VideoCaptureDevice> FileVideoCaptureDeviceFactory::CreateDevice(
     const VideoCaptureDeviceDescriptor& device_descriptor) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  base::ThreadRestrictions::AssertIOAllowed();
+  base::AssertBlockingAllowed();
 #if defined(OS_WIN)
   return std::unique_ptr<VideoCaptureDevice>(new FileVideoCaptureDevice(
       base::FilePath(base::SysUTF8ToWide(device_descriptor.display_name))));
@@ -67,7 +67,7 @@ void FileVideoCaptureDeviceFactory::GetSupportedFormats(
     const VideoCaptureDeviceDescriptor& device_descriptor,
     VideoCaptureFormats* supported_formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  base::ThreadRestrictions::AssertIOAllowed();
+  base::AssertBlockingAllowed();
 
   VideoCaptureFormat capture_format;
   if (!FileVideoCaptureDevice::GetVideoCaptureFormat(
diff --git a/chromium/media/capture/video/linux/camera_config_chromeos.cc b/chromium/media/capture/video/linux/camera_config_chromeos.cc
index a840c91f84e..500c0e7fcec 100644
--- a/chromium/media/capture/video/linux/camera_config_chromeos.cc
+++ b/chromium/media/capture/video/linux/camera_config_chromeos.cc
@@ -48,7 +48,7 @@ CameraConfigChromeOS::CameraConfigChromeOS(
   InitializeDeviceInfo(config_file_path);
 }
 
-CameraConfigChromeOS::~CameraConfigChromeOS() {}
+CameraConfigChromeOS::~CameraConfigChromeOS() = default;
 
 VideoFacingMode CameraConfigChromeOS::GetCameraFacing(
     const std::string& device_id,
diff --git a/chromium/media/capture/video/linux/v4l2_capture_delegate.cc b/chromium/media/capture/video/linux/v4l2_capture_delegate.cc
index 4455fdb82a2..7cb3b857335 100644
--- a/chromium/media/capture/video/linux/v4l2_capture_delegate.cc
+++ b/chromium/media/capture/video/linux/v4l2_capture_delegate.cc
@@ -753,7 +753,7 @@ base::WeakPtr<V4L2CaptureDelegate> V4L2CaptureDelegate::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
-V4L2CaptureDelegate::~V4L2CaptureDelegate() {}
+V4L2CaptureDelegate::~V4L2CaptureDelegate() = default;
 
 bool V4L2CaptureDelegate::MapAndQueueBuffer(int index) {
   v4l2_buffer buffer;
@@ -837,6 +837,11 @@ void V4L2CaptureDelegate::DoCapture() {
       buffer.bytesused = 0;
     } else
 #endif
+        if (buffer.bytesused < capture_format_.ImageAllocationSize()) {
+      LOG(ERROR) << "Dequeued v4l2 buffer contains invalid length ("
+                 << buffer.bytesused << " bytes).";
+      buffer.bytesused = 0;
+    } else
       client_->OnIncomingCapturedData(
           buffer_tracker->start(), buffer_tracker->payload_size(),
           capture_format_, rotation_, now, timestamp);
@@ -869,7 +874,7 @@ void V4L2CaptureDelegate::SetErrorState(const base::Location& from_here,
   client_->OnError(from_here, reason);
 }
 
-V4L2CaptureDelegate::BufferTracker::BufferTracker() {}
+V4L2CaptureDelegate::BufferTracker::BufferTracker() = default;
 
 V4L2CaptureDelegate::BufferTracker::~BufferTracker() {
   if (start_ == nullptr)
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 43a220cc619..d363659916d 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
@@ -2,11 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Reduce number of log messages by logging each NOTIMPLEMENTED() only once.
-// // This has to be before any other includes, else default is picked up.
-// // See base/logging.h for details on this.
-// #define NOTIMPLEMENTED_POLICY 5
-
 #include "media/capture/video/linux/video_capture_device_factory_linux.h"
 
 #include <errno.h>
@@ -104,7 +99,7 @@ std::list<float> GetFrameRateList(int fd,
     } else if (frame_interval.type == V4L2_FRMIVAL_TYPE_CONTINUOUS ||
                frame_interval.type == V4L2_FRMIVAL_TYPE_STEPWISE) {
       // TODO(mcasas): see http://crbug.com/249953, support these devices.
-      NOTIMPLEMENTED();
+      NOTIMPLEMENTED_LOG_ONCE();
       break;
     }
   }
@@ -140,7 +135,7 @@ void GetSupportedFormatsForV4L2BufferType(
       } else if (frame_size.type == V4L2_FRMSIZE_TYPE_STEPWISE ||
                  frame_size.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) {
         // TODO(mcasas): see http://crbug.com/249953, support these devices.
-        NOTIMPLEMENTED();
+        NOTIMPLEMENTED_LOG_ONCE();
       }
 
       const std::list<float> frame_rates = GetFrameRateList(
@@ -199,8 +194,7 @@ VideoCaptureDeviceFactoryLinux::VideoCaptureDeviceFactoryLinux(
     : ui_task_runner_(ui_task_runner) {
 }
 
-VideoCaptureDeviceFactoryLinux::~VideoCaptureDeviceFactoryLinux() {
-}
+VideoCaptureDeviceFactoryLinux::~VideoCaptureDeviceFactoryLinux() = default;
 
 std::unique_ptr<VideoCaptureDevice>
 VideoCaptureDeviceFactoryLinux::CreateDevice(
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 1fa0be20a0d..6d7e8457642 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
@@ -15,9 +15,9 @@
 
 namespace {
 
-// DeckLink SDK uses ScopedComPtr-style APIs. Chrome ScopedComPtr is only
-// available for Windows builds. This is a verbatim knock-off of the needed
-// parts of base::win::ScopedComPtr<> for ref counting.
+// DeckLink SDK uses ComPtr-style APIs. Microsoft::WRL::ComPtr<> is only
+// available for Windows builds. This provides a subset of the methods required
+// for ref counting.
 template <class T>
 class ScopedDeckLinkPtr : public scoped_refptr<T> {
  private:
diff --git a/chromium/media/capture/video/mock_video_frame_receiver.cc b/chromium/media/capture/video/mock_video_frame_receiver.cc
new file mode 100644
index 00000000000..fcd6199c014
--- /dev/null
+++ b/chromium/media/capture/video/mock_video_frame_receiver.cc
@@ -0,0 +1,13 @@
+// Copyright 2017 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 "media/capture/video/mock_video_frame_receiver.h"
+
+namespace media {
+
+MockVideoFrameReceiver::MockVideoFrameReceiver() = default;
+
+MockVideoFrameReceiver::~MockVideoFrameReceiver() = default;
+
+}  // namespace media
diff --git a/chromium/media/capture/video/mock_video_frame_receiver.h b/chromium/media/capture/video/mock_video_frame_receiver.h
new file mode 100644
index 00000000000..35c5fc441ab
--- /dev/null
+++ b/chromium/media/capture/video/mock_video_frame_receiver.h
@@ -0,0 +1,52 @@
+// Copyright 2017 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 MEDIA_CAPTURE_VIDEO_MOCK_VIDEO_FRAME_RECEIVER_H_
+#define MEDIA_CAPTURE_VIDEO_MOCK_VIDEO_FRAME_RECEIVER_H_
+
+#include "media/capture/video/video_frame_receiver.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace media {
+
+class MockVideoFrameReceiver : public VideoFrameReceiver {
+ public:
+  MockVideoFrameReceiver();
+  ~MockVideoFrameReceiver() override;
+
+  MOCK_METHOD1(MockOnNewBufferHandle, void(int buffer_id));
+  MOCK_METHOD3(
+      MockOnFrameReadyInBuffer,
+      void(int buffer_id,
+           std::unique_ptr<media::VideoCaptureDevice::Client::Buffer::
+                               ScopedAccessPermission>* buffer_read_permission,
+           const gfx::Size&));
+  MOCK_METHOD0(OnError, void());
+  MOCK_METHOD1(OnLog, void(const std::string& message));
+  MOCK_METHOD1(OnBufferRetired, void(int buffer_id));
+  MOCK_METHOD0(OnStarted, void());
+  MOCK_METHOD0(OnStartedUsingGpuDecode, void());
+
+  void OnNewBufferHandle(
+      int buffer_id,
+      std::unique_ptr<media::VideoCaptureDevice::Client::Buffer::HandleProvider>
+          handle_provider) override {
+    MockOnNewBufferHandle(buffer_id);
+  }
+
+  void OnFrameReadyInBuffer(
+      int32_t buffer_id,
+      int frame_feedback_id,
+      std::unique_ptr<
+          media::VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
+          buffer_read_permission,
+      media::mojom::VideoFrameInfoPtr frame_info) override {
+    MockOnFrameReadyInBuffer(buffer_id, &buffer_read_permission,
+                             frame_info->coded_size);
+  }
+};
+
+}  // namespace media
+
+#endif  // MEDIA_CAPTURE_VIDEO_MOCK_VIDEO_FRAME_RECEIVER_H_
diff --git a/chromium/media/capture/video/scoped_buffer_pool_reservation.h b/chromium/media/capture/video/scoped_buffer_pool_reservation.h
new file mode 100644
index 00000000000..1a74e605f65
--- /dev/null
+++ b/chromium/media/capture/video/scoped_buffer_pool_reservation.h
@@ -0,0 +1,49 @@
+// Copyright 2017 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 MEDIA_CAPTURE_VIDEO_SCOPED_BUFFER_POOL_RESERVATION_H_
+#define MEDIA_CAPTURE_VIDEO_SCOPED_BUFFER_POOL_RESERVATION_H_
+
+#include "media/capture/capture_export.h"
+#include "media/capture/video/video_capture_buffer_pool.h"
+#include "media/capture/video/video_capture_device_client.h"
+
+namespace media {
+
+template <typename ReleaseTraits>
+class CAPTURE_EXPORT ScopedBufferPoolReservation
+    : public VideoCaptureDevice::Client::Buffer::ScopedAccessPermission {
+ public:
+  ScopedBufferPoolReservation(scoped_refptr<VideoCaptureBufferPool> buffer_pool,
+                              int buffer_id)
+      : buffer_pool_(std::move(buffer_pool)), buffer_id_(buffer_id) {}
+
+  ~ScopedBufferPoolReservation() {
+    ReleaseTraits::Release(buffer_pool_, buffer_id_);
+  }
+
+ private:
+  const scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
+  const int buffer_id_;
+};
+
+class CAPTURE_EXPORT ProducerReleaseTraits {
+ public:
+  static void Release(const scoped_refptr<VideoCaptureBufferPool>& buffer_pool,
+                      int buffer_id) {
+    buffer_pool->RelinquishProducerReservation(buffer_id);
+  }
+};
+
+class CAPTURE_EXPORT ConsumerReleaseTraits {
+ public:
+  static void Release(const scoped_refptr<VideoCaptureBufferPool>& buffer_pool,
+                      int buffer_id) {
+    buffer_pool->RelinquishConsumerHold(buffer_id, 1 /* num_clients */);
+  }
+};
+
+}  // namespace media
+
+#endif  // MEDIA_CAPTURE_VIDEO_SCOPED_BUFFER_POOL_RESERVATION_H_
diff --git a/chromium/media/capture/video/shared_memory_handle_provider.cc b/chromium/media/capture/video/shared_memory_handle_provider.cc
index bb10c070156..9d82d324df7 100644
--- a/chromium/media/capture/video/shared_memory_handle_provider.cc
+++ b/chromium/media/capture/video/shared_memory_handle_provider.cc
@@ -70,7 +70,7 @@ SharedMemoryHandleProvider::GetHandleForInterProcessTransit(bool read_only) {
   }
   return mojo::WrapSharedMemoryHandle(
       base::SharedMemory::DuplicateHandle(shared_memory_->handle()),
-      mapped_size_, read_only_flag_);
+      mapped_size_, read_only);
 }
 
 base::SharedMemoryHandle
diff --git a/chromium/media/capture/video/video_capture_buffer_pool_impl.cc b/chromium/media/capture/video/video_capture_buffer_pool_impl.cc
index 9ef965daf78..e9833837daa 100644
--- a/chromium/media/capture/video/video_capture_buffer_pool_impl.cc
+++ b/chromium/media/capture/video/video_capture_buffer_pool_impl.cc
@@ -25,7 +25,7 @@ VideoCaptureBufferPoolImpl::VideoCaptureBufferPoolImpl(
   DCHECK_GT(count, 0);
 }
 
-VideoCaptureBufferPoolImpl::~VideoCaptureBufferPoolImpl() {}
+VideoCaptureBufferPoolImpl::~VideoCaptureBufferPoolImpl() = default;
 
 mojo::ScopedSharedBufferHandle
 VideoCaptureBufferPoolImpl::GetHandleForInterProcessTransit(int buffer_id,
diff --git a/chromium/media/capture/video/video_capture_device.cc b/chromium/media/capture/video/video_capture_device.cc
index df3997ca0a2..f39cdbaf3fc 100644
--- a/chromium/media/capture/video/video_capture_device.cc
+++ b/chromium/media/capture/video/video_capture_device.cc
@@ -33,7 +33,7 @@ VideoCaptureDevice::Client::Buffer::~Buffer() = default;
 VideoCaptureDevice::Client::Buffer& VideoCaptureDevice::Client::Buffer::
 operator=(VideoCaptureDevice::Client::Buffer&& other) = default;
 
-VideoCaptureDevice::~VideoCaptureDevice() {}
+VideoCaptureDevice::~VideoCaptureDevice() = default;
 
 void VideoCaptureDevice::GetPhotoState(GetPhotoStateCallback callback) {}
 
diff --git a/chromium/media/capture/video/video_capture_device_client.cc b/chromium/media/capture/video/video_capture_device_client.cc
index 212dc565c52..311605a5aa8 100644
--- a/chromium/media/capture/video/video_capture_device_client.cc
+++ b/chromium/media/capture/video/video_capture_device_client.cc
@@ -16,6 +16,7 @@
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
+#include "media/capture/video/scoped_buffer_pool_reservation.h"
 #include "media/capture/video/video_capture_buffer_handle.h"
 #include "media/capture/video/video_capture_buffer_pool.h"
 #include "media/capture/video/video_capture_jpeg_decoder.h"
@@ -37,39 +38,6 @@ bool IsFormatSupported(media::VideoPixelFormat pixel_format) {
 
 namespace media {
 
-template <typename ReleaseTraits>
-class ScopedBufferPoolReservation
-    : public VideoCaptureDevice::Client::Buffer::ScopedAccessPermission {
- public:
-  ScopedBufferPoolReservation(scoped_refptr<VideoCaptureBufferPool> buffer_pool,
-                              int buffer_id)
-      : buffer_pool_(std::move(buffer_pool)), buffer_id_(buffer_id) {}
-
-  ~ScopedBufferPoolReservation() override {
-    ReleaseTraits::Release(buffer_pool_, buffer_id_);
-  }
-
- private:
-  const scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
-  const int buffer_id_;
-};
-
-class ProducerReleaseTraits {
- public:
-  static void Release(const scoped_refptr<VideoCaptureBufferPool>& buffer_pool,
-                      int buffer_id) {
-    buffer_pool->RelinquishProducerReservation(buffer_id);
-  }
-};
-
-class ConsumerReleaseTraits {
- public:
-  static void Release(const scoped_refptr<VideoCaptureBufferPool>& buffer_pool,
-                      int buffer_id) {
-    buffer_pool->RelinquishConsumerHold(buffer_id, 1);
-  }
-};
-
 class BufferPoolBufferHandleProvider
     : public VideoCaptureDevice::Client::Buffer::HandleProvider {
  public:
diff --git a/chromium/media/capture/video/video_capture_device_client_unittest.cc b/chromium/media/capture/video/video_capture_device_client_unittest.cc
index c3422c73f0e..b12873134dd 100644
--- a/chromium/media/capture/video/video_capture_device_client_unittest.cc
+++ b/chromium/media/capture/video/video_capture_device_client_unittest.cc
@@ -13,6 +13,7 @@
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "media/base/limits.h"
+#include "media/capture/video/mock_video_frame_receiver.h"
 #include "media/capture/video/video_capture_buffer_pool_impl.h"
 #include "media/capture/video/video_capture_buffer_tracker_factory_impl.h"
 #include "media/capture/video/video_capture_jpeg_decoder.h"
@@ -30,44 +31,12 @@ namespace media {
 
 namespace {
 
-class MockVideoCaptureController : public VideoFrameReceiver {
- public:
-  MOCK_METHOD1(MockOnNewBufferHandle, void(int buffer_id));
-  MOCK_METHOD3(
-      MockOnFrameReadyInBuffer,
-      void(int buffer_id,
-           std::unique_ptr<media::VideoCaptureDevice::Client::Buffer::
-                               ScopedAccessPermission>* buffer_read_permission,
-           const gfx::Size&));
-  MOCK_METHOD0(OnError, void());
-  MOCK_METHOD1(OnLog, void(const std::string& message));
-  MOCK_METHOD1(OnBufferRetired, void(int buffer_id));
-  MOCK_METHOD0(OnStarted, void());
-  MOCK_METHOD0(OnStartedUsingGpuDecode, void());
-
-  void OnNewBufferHandle(
-      int buffer_id,
-      std::unique_ptr<media::VideoCaptureDevice::Client::Buffer::HandleProvider>
-          handle_provider) override {
-    MockOnNewBufferHandle(buffer_id);
-  }
-
-  void OnFrameReadyInBuffer(
-      int32_t buffer_id,
-      int frame_feedback_id,
-      std::unique_ptr<
-          media::VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
-          buffer_read_permission,
-      media::mojom::VideoFrameInfoPtr frame_info) override {
-    MockOnFrameReadyInBuffer(buffer_id, &buffer_read_permission,
-                             frame_info->coded_size);
-  }
-};
-
 std::unique_ptr<media::VideoCaptureJpegDecoder> ReturnNullPtrAsJpecDecoder() {
   return nullptr;
 }
 
+}  // namespace
+
 // Test fixture for testing a unit consisting of an instance of
 // VideoCaptureDeviceClient connected to a partly-mocked instance of
 // VideoCaptureController, and an instance of VideoCaptureBufferPoolImpl
@@ -80,24 +49,22 @@ class VideoCaptureDeviceClientTest : public ::testing::Test {
         new media::VideoCaptureBufferPoolImpl(
             base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(),
             1));
-    auto controller = base::MakeUnique<MockVideoCaptureController>();
-    controller_ = controller.get();
+    auto controller = base::MakeUnique<MockVideoFrameReceiver>();
+    receiver_ = controller.get();
     device_client_ = base::MakeUnique<media::VideoCaptureDeviceClient>(
         std::move(controller), buffer_pool,
         base::Bind(&ReturnNullPtrAsJpecDecoder));
   }
-  ~VideoCaptureDeviceClientTest() override {}
+  ~VideoCaptureDeviceClientTest() override = default;
 
  protected:
-  MockVideoCaptureController* controller_;
+  MockVideoFrameReceiver* receiver_;
   std::unique_ptr<media::VideoCaptureDeviceClient> device_client_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureDeviceClientTest);
 };
 
-}  // namespace
-
 // A small test for reference and to verify VideoCaptureDeviceClient is
 // minimally functional.
 TEST_F(VideoCaptureDeviceClientTest, Minimal) {
@@ -110,16 +77,15 @@ TEST_F(VideoCaptureDeviceClientTest, Minimal) {
   {
     InSequence s;
     const int expected_buffer_id = 0;
-    EXPECT_CALL(*controller_, OnLog(_));
-    EXPECT_CALL(*controller_, MockOnNewBufferHandle(expected_buffer_id));
-    EXPECT_CALL(*controller_,
-                MockOnFrameReadyInBuffer(expected_buffer_id, _, _));
-    EXPECT_CALL(*controller_, OnBufferRetired(expected_buffer_id));
+    EXPECT_CALL(*receiver_, OnLog(_));
+    EXPECT_CALL(*receiver_, MockOnNewBufferHandle(expected_buffer_id));
+    EXPECT_CALL(*receiver_, MockOnFrameReadyInBuffer(expected_buffer_id, _, _));
+    EXPECT_CALL(*receiver_, OnBufferRetired(expected_buffer_id));
   }
   device_client_->OnIncomingCapturedData(data, kScratchpadSizeInBytes,
                                          kFrameFormat, 0 /*clockwise rotation*/,
                                          base::TimeTicks(), base::TimeDelta());
-  // Releasing |device_client_| will also release |controller_|.
+  // Releasing |device_client_| will also release |receiver_|.
   device_client_.reset();
 }
 
@@ -135,12 +101,12 @@ TEST_F(VideoCaptureDeviceClientTest, FailsSilentlyGivenInvalidFrameFormat) {
       media::VideoPixelStorage::PIXEL_STORAGE_CPU);
   DCHECK(device_client_.get());
   // Expect the the call to fail silently inside the VideoCaptureDeviceClient.
-  EXPECT_CALL(*controller_, OnLog(_)).Times(1);
-  EXPECT_CALL(*controller_, MockOnFrameReadyInBuffer(_, _, _)).Times(0);
+  EXPECT_CALL(*receiver_, OnLog(_)).Times(1);
+  EXPECT_CALL(*receiver_, MockOnFrameReadyInBuffer(_, _, _)).Times(0);
   device_client_->OnIncomingCapturedData(data, kScratchpadSizeInBytes,
                                          kFrameFormat, 0 /*clockwise rotation*/,
                                          base::TimeTicks(), base::TimeDelta());
-  Mock::VerifyAndClearExpectations(controller_);
+  Mock::VerifyAndClearExpectations(receiver_);
 }
 
 // Tests that we fail silently if no available buffers to use.
@@ -150,19 +116,20 @@ TEST_F(VideoCaptureDeviceClientTest, DropsFrameIfNoBuffer) {
   const media::VideoCaptureFormat kFrameFormat(
       gfx::Size(10, 10), 30.0f /*frame_rate*/, media::PIXEL_FORMAT_I420,
       media::PIXEL_STORAGE_CPU);
-  EXPECT_CALL(*controller_, OnLog(_)).Times(1);
+  EXPECT_CALL(*receiver_, OnLog(_)).Times(1);
   // Simulate that receiver still holds |buffer_read_permission| for the first
   // buffer when the second call to OnIncomingCapturedData comes in.
   // Since we set up the buffer pool to max out at 1 buffer, this should cause
   // |device_client_| to drop the frame.
   std::unique_ptr<VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
       read_permission;
-  EXPECT_CALL(*controller_, MockOnFrameReadyInBuffer(_, _, _))
+  EXPECT_CALL(*receiver_, MockOnFrameReadyInBuffer(_, _, _))
       .WillOnce(Invoke([&read_permission](
-          int buffer_id,
-          std::unique_ptr<media::VideoCaptureDevice::Client::Buffer::
-                              ScopedAccessPermission>* buffer_read_permission,
-          const gfx::Size&) {
+                           int buffer_id,
+                           std::unique_ptr<media::VideoCaptureDevice::Client::
+                                               Buffer::ScopedAccessPermission>*
+                               buffer_read_permission,
+                           const gfx::Size&) {
         read_permission = std::move(*buffer_read_permission);
       }));
   // Pass two frames. The second will be dropped.
@@ -172,7 +139,7 @@ TEST_F(VideoCaptureDeviceClientTest, DropsFrameIfNoBuffer) {
   device_client_->OnIncomingCapturedData(data, kScratchpadSizeInBytes,
                                          kFrameFormat, 0 /*clockwise rotation*/,
                                          base::TimeTicks(), base::TimeDelta());
-  Mock::VerifyAndClearExpectations(controller_);
+  Mock::VerifyAndClearExpectations(receiver_);
 }
 
 // Tests that buffer-based capture API accepts some memory-backed pixel formats.
@@ -211,13 +178,13 @@ TEST_F(VideoCaptureDeviceClientTest, DataCaptureGoodPixelFormats) {
   for (media::VideoPixelFormat format : kSupportedFormats) {
     params.requested_format.pixel_format = format;
 
-    EXPECT_CALL(*controller_, OnLog(_)).Times(1);
-    EXPECT_CALL(*controller_, MockOnFrameReadyInBuffer(_, _, _)).Times(1);
+    EXPECT_CALL(*receiver_, OnLog(_)).Times(1);
+    EXPECT_CALL(*receiver_, MockOnFrameReadyInBuffer(_, _, _)).Times(1);
     device_client_->OnIncomingCapturedData(
         data, params.requested_format.ImageAllocationSize(),
         params.requested_format, 0 /* clockwise_rotation */, base::TimeTicks(),
         base::TimeDelta());
-    Mock::VerifyAndClearExpectations(controller_);
+    Mock::VerifyAndClearExpectations(receiver_);
   }
 }
 
@@ -240,7 +207,7 @@ TEST_F(VideoCaptureDeviceClientTest, CheckRotationsAndCrops) {
   const size_t kScratchpadSizeInBytes = 400;
   unsigned char data[kScratchpadSizeInBytes] = {};
 
-  EXPECT_CALL(*controller_, OnLog(_)).Times(1);
+  EXPECT_CALL(*receiver_, OnLog(_)).Times(1);
 
   media::VideoCaptureParams params;
   for (const auto& size_and_rotation : kSizeAndRotations) {
@@ -250,7 +217,7 @@ TEST_F(VideoCaptureDeviceClientTest, CheckRotationsAndCrops) {
     params.requested_format = media::VideoCaptureFormat(
         size_and_rotation.input_resolution, 30.0f, media::PIXEL_FORMAT_ARGB);
     gfx::Size coded_size;
-    EXPECT_CALL(*controller_, MockOnFrameReadyInBuffer(_, _, _))
+    EXPECT_CALL(*receiver_, MockOnFrameReadyInBuffer(_, _, _))
         .Times(1)
         .WillOnce(SaveArg<2>(&coded_size));
     device_client_->OnIncomingCapturedData(
@@ -262,7 +229,7 @@ TEST_F(VideoCaptureDeviceClientTest, CheckRotationsAndCrops) {
     EXPECT_EQ(coded_size.height(),
               size_and_rotation.output_resolution.height());
 
-    Mock::VerifyAndClearExpectations(controller_);
+    Mock::VerifyAndClearExpectations(receiver_);
   }
 }
 
diff --git a/chromium/media/capture/video/video_capture_device_descriptor.cc b/chromium/media/capture/video/video_capture_device_descriptor.cc
index 701160846ac..b5a34f34e35 100644
--- a/chromium/media/capture/video/video_capture_device_descriptor.cc
+++ b/chromium/media/capture/video/video_capture_device_descriptor.cc
@@ -38,7 +38,7 @@ VideoCaptureDeviceDescriptor::VideoCaptureDeviceDescriptor(
       capture_api(capture_api),
       transport_type(transport_type) {}
 
-VideoCaptureDeviceDescriptor::~VideoCaptureDeviceDescriptor() {}
+VideoCaptureDeviceDescriptor::~VideoCaptureDeviceDescriptor() = default;
 
 VideoCaptureDeviceDescriptor::VideoCaptureDeviceDescriptor(
     const VideoCaptureDeviceDescriptor& other) = default;
diff --git a/chromium/media/capture/video/video_capture_device_factory.cc b/chromium/media/capture/video/video_capture_device_factory.cc
index f48265919f8..cefeb5c0043 100644
--- a/chromium/media/capture/video/video_capture_device_factory.cc
+++ b/chromium/media/capture/video/video_capture_device_factory.cc
@@ -49,7 +49,7 @@ VideoCaptureDeviceFactory::VideoCaptureDeviceFactory() {
   thread_checker_.DetachFromThread();
 }
 
-VideoCaptureDeviceFactory::~VideoCaptureDeviceFactory() {}
+VideoCaptureDeviceFactory::~VideoCaptureDeviceFactory() = default;
 
 #if !defined(OS_MACOSX) && !defined(OS_LINUX) && !defined(OS_ANDROID) && \
     !defined(OS_WIN)
diff --git a/chromium/media/capture/video/video_capture_device_unittest.cc b/chromium/media/capture/video/video_capture_device_unittest.cc
index 0c52e83746e..51600678f0a 100644
--- a/chromium/media/capture/video/video_capture_device_unittest.cc
+++ b/chromium/media/capture/video/video_capture_device_unittest.cc
@@ -45,6 +45,8 @@
 #endif
 
 #if defined(OS_CHROMEOS)
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/fake_power_manager_client.h"
 #include "media/capture/video/chromeos/camera_buffer_factory.h"
 #include "media/capture/video/chromeos/local_gpu_memory_buffer_manager.h"
 #include "media/capture/video/chromeos/video_capture_device_arc_chromeos.h"
@@ -219,7 +221,7 @@ class MockImageCaptureClient
 
  private:
   friend class base::RefCountedThreadSafe<MockImageCaptureClient>;
-  virtual ~MockImageCaptureClient() {}
+  virtual ~MockImageCaptureClient() = default;
 
   mojom::PhotoStatePtr state_;
 };
@@ -230,7 +232,7 @@ class MojoEnabledTestEnvironment final : public testing::Environment {
  public:
   MojoEnabledTestEnvironment() : mojo_ipc_thread_("MojoIpcThread") {}
 
-  ~MojoEnabledTestEnvironment() final {}
+  ~MojoEnabledTestEnvironment() final = default;
 
   void SetUp() final {
     mojo::edk::Init();
@@ -271,6 +273,7 @@ class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
         image_capture_client_(new MockImageCaptureClient()),
 #if defined(OS_CHROMEOS)
         local_gpu_memory_buffer_manager_(new LocalGpuMemoryBufferManager()),
+        dbus_setter_(chromeos::DBusThreadManager::GetSetterForTesting()),
 #endif
         video_capture_device_factory_(VideoCaptureDeviceFactory::CreateFactory(
             base::ThreadTaskRunnerHandle::Get(),
@@ -283,6 +286,10 @@ class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
   }
 
   void SetUp() override {
+#if defined(OS_CHROMEOS)
+    dbus_setter_->SetPowerManagerClient(
+        base::MakeUnique<chromeos::FakePowerManagerClient>());
+#endif
 #if defined(OS_ANDROID)
     static_cast<VideoCaptureDeviceFactoryAndroid*>(
         video_capture_device_factory_.get())
@@ -387,6 +394,7 @@ class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
 #if defined(OS_CHROMEOS)
   const std::unique_ptr<LocalGpuMemoryBufferManager>
       local_gpu_memory_buffer_manager_;
+  std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter_;
 #endif
   const std::unique_ptr<VideoCaptureDeviceFactory>
       video_capture_device_factory_;
diff --git a/chromium/media/capture/video/video_capture_jpeg_decoder.h b/chromium/media/capture/video/video_capture_jpeg_decoder.h
index 82305922490..535349cee3b 100644
--- a/chromium/media/capture/video/video_capture_jpeg_decoder.h
+++ b/chromium/media/capture/video/video_capture_jpeg_decoder.h
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef MEDIA_CAPTURE_VIDEO_VIDEO_CAPTURE_JPEG_DECODER_H_
+#define MEDIA_CAPTURE_VIDEO_VIDEO_CAPTURE_JPEG_DECODER_H_
+
 #include "base/callback.h"
 #include "media/capture/capture_export.h"
 #include "media/capture/mojo/video_capture_types.mojom.h"
@@ -47,3 +50,5 @@ class CAPTURE_EXPORT VideoCaptureJpegDecoder {
 };
 
 }  // namespace media
+
+#endif  // MEDIA_CAPTURE_VIDEO_VIDEO_CAPTURE_JPEG_DECODER_H_
diff --git a/chromium/media/capture/video/win/filter_base_win.h b/chromium/media/capture/video/win/filter_base_win.h
index 57329d42696..5a3ecb0ce5e 100644
--- a/chromium/media/capture/video/win/filter_base_win.h
+++ b/chromium/media/capture/video/win/filter_base_win.h
@@ -12,10 +12,10 @@
 #define NO_DSHOW_STRSAFE
 #include <dshow.h>
 #include <stddef.h>
+#include <wrl/client.h>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/win/scoped_comptr.h"
 
 namespace media {
 
@@ -66,7 +66,7 @@ class FilterBase : public IBaseFilter, public base::RefCounted<FilterBase> {
 
  private:
   FILTER_STATE state_;
-  base::win::ScopedComPtr<IFilterGraph> owning_graph_;
+  Microsoft::WRL::ComPtr<IFilterGraph> owning_graph_;
 
   DISALLOW_COPY_AND_ASSIGN(FilterBase);
 };
diff --git a/chromium/media/capture/video/win/pin_base_win.h b/chromium/media/capture/video/win/pin_base_win.h
index 43cfc49955d..692e4664ba3 100644
--- a/chromium/media/capture/video/win/pin_base_win.h
+++ b/chromium/media/capture/video/win/pin_base_win.h
@@ -11,9 +11,9 @@
 // Avoid including strsafe.h via dshow as it will cause build warnings.
 #define NO_DSHOW_STRSAFE
 #include <dshow.h>
+#include <wrl/client.h>
 
 #include "base/memory/ref_counted.h"
-#include "base/win/scoped_comptr.h"
 
 namespace media {
 
@@ -100,7 +100,7 @@ class PinBase : public IPin,
 
  private:
   AM_MEDIA_TYPE current_media_type_;
-  base::win::ScopedComPtr<IPin> connected_pin_;
+  Microsoft::WRL::ComPtr<IPin> connected_pin_;
   // owner_ is the filter owning this pin. We don't reference count it since
   // that would create a circular reference count.
   IBaseFilter* owner_;
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 0dcb425df9a..fec2ed9b27f 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
@@ -8,6 +8,7 @@
 #include <mferror.h>
 #include <objbase.h>
 #include <stddef.h>
+#include <wrl/client.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ -22,11 +23,11 @@
 #include "media/capture/video/win/video_capture_device_mf_win.h"
 #include "media/capture/video/win/video_capture_device_win.h"
 
-using base::win::ScopedCoMem;
-using base::win::ScopedComPtr;
-using base::win::ScopedVariant;
 using Descriptor = media::VideoCaptureDeviceDescriptor;
 using Descriptors = media::VideoCaptureDeviceDescriptors;
+using Microsoft::WRL::ComPtr;
+using base::win::ScopedCoMem;
+using base::win::ScopedVariant;
 
 namespace media {
 
@@ -99,7 +100,7 @@ static bool PrepareVideoCaptureAttributesMediaFoundation(
 
 static bool CreateVideoCaptureDeviceMediaFoundation(const char* sym_link,
                                                     IMFMediaSource** source) {
-  ScopedComPtr<IMFAttributes> attributes;
+  ComPtr<IMFAttributes> attributes;
   if (!PrepareVideoCaptureAttributesMediaFoundation(attributes.GetAddressOf(),
                                                     2))
     return false;
@@ -112,7 +113,7 @@ static bool CreateVideoCaptureDeviceMediaFoundation(const char* sym_link,
 
 static bool EnumerateVideoDevicesMediaFoundation(IMFActivate*** devices,
                                                  UINT32* count) {
-  ScopedComPtr<IMFAttributes> attributes;
+  ComPtr<IMFAttributes> attributes;
   if (!PrepareVideoCaptureAttributesMediaFoundation(attributes.GetAddressOf(),
                                                     1))
     return false;
@@ -159,13 +160,13 @@ static void GetDeviceDescriptorsDirectShow(Descriptors* device_descriptors) {
   DCHECK(device_descriptors);
   DVLOG(1) << __func__;
 
-  ScopedComPtr<ICreateDevEnum> dev_enum;
+  ComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = ::CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
                                   IID_PPV_ARGS(&dev_enum));
   if (FAILED(hr))
     return;
 
-  ScopedComPtr<IEnumMoniker> enum_moniker;
+  ComPtr<IEnumMoniker> enum_moniker;
   hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
                                        enum_moniker.GetAddressOf(), 0);
   // CreateClassEnumerator returns S_FALSE on some Windows OS
@@ -174,10 +175,10 @@ static void GetDeviceDescriptorsDirectShow(Descriptors* device_descriptors) {
     return;
 
   // Enumerate all video capture devices.
-  for (ScopedComPtr<IMoniker> moniker;
+  for (ComPtr<IMoniker> moniker;
        enum_moniker->Next(1, moniker.GetAddressOf(), NULL) == S_OK;
        moniker.Reset()) {
-    ScopedComPtr<IPropertyBag> prop_bag;
+    ComPtr<IPropertyBag> prop_bag;
     hr = moniker->BindToStorage(0, 0, IID_PPV_ARGS(&prop_bag));
     if (FAILED(hr))
       continue;
@@ -268,13 +269,13 @@ static void GetDeviceSupportedFormatsMediaFoundation(
     VideoCaptureFormats* formats) {
   DVLOG(1) << "GetDeviceSupportedFormatsMediaFoundation for "
            << descriptor.display_name;
-  ScopedComPtr<IMFMediaSource> source;
+  ComPtr<IMFMediaSource> source;
   if (!CreateVideoCaptureDeviceMediaFoundation(descriptor.device_id.c_str(),
                                                source.GetAddressOf())) {
     return;
   }
 
-  base::win::ScopedComPtr<IMFSourceReader> reader;
+  ComPtr<IMFSourceReader> reader;
   HRESULT hr = MFCreateSourceReaderFromMediaSource(source.Get(), NULL,
                                                    reader.GetAddressOf());
   if (FAILED(hr)) {
@@ -284,7 +285,7 @@ static void GetDeviceSupportedFormatsMediaFoundation(
   }
 
   DWORD stream_index = 0;
-  ScopedComPtr<IMFMediaType> type;
+  ComPtr<IMFMediaType> type;
   while (SUCCEEDED(reader->GetNativeMediaType(kFirstVideoStream, stream_index,
                                               type.GetAddressOf()))) {
     UINT32 width, height;
@@ -350,7 +351,7 @@ std::unique_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryWin::CreateDevice(
     DCHECK(PlatformSupportsMediaFoundation());
     device.reset(new VideoCaptureDeviceMFWin(device_descriptor));
     DVLOG(1) << " MediaFoundation Device: " << device_descriptor.display_name;
-    ScopedComPtr<IMFMediaSource> source;
+    ComPtr<IMFMediaSource> source;
     if (!CreateVideoCaptureDeviceMediaFoundation(
             device_descriptor.device_id.c_str(), source.GetAddressOf())) {
       return std::unique_ptr<VideoCaptureDevice>();
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 b4a4719faf2..73a144b36d6 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
@@ -21,7 +21,6 @@
 #include "media/capture/video/win/sink_filter_win.h"
 
 using base::win::ScopedCoMem;
-using base::win::ScopedComPtr;
 
 namespace media {
 
@@ -60,7 +59,7 @@ static bool FillFormat(IMFMediaType* type, VideoCaptureFormat* format) {
 HRESULT FillCapabilities(IMFSourceReader* source,
                          CapabilityList* capabilities) {
   DWORD stream_index = 0;
-  ScopedComPtr<IMFMediaType> type;
+  Microsoft::WRL::ComPtr<IMFMediaType> type;
   HRESULT hr;
   while (SUCCEEDED(hr = source->GetNativeMediaType(
                        kFirstVideoStream, stream_index, type.GetAddressOf()))) {
@@ -122,7 +121,7 @@ class MFReaderCallback final
     sample->GetBufferCount(&count);
 
     for (DWORD i = 0; i < count; ++i) {
-      ScopedComPtr<IMFMediaBuffer> buffer;
+      Microsoft::WRL::ComPtr<IMFMediaBuffer> buffer;
       sample->GetBufferByIndex(i, buffer.GetAddressOf());
       if (buffer.Get()) {
         DWORD length = 0, max_length = 0;
@@ -197,11 +196,11 @@ VideoCaptureDeviceMFWin::~VideoCaptureDeviceMFWin() {
 }
 
 bool VideoCaptureDeviceMFWin::Init(
-    const base::win::ScopedComPtr<IMFMediaSource>& source) {
+    const Microsoft::WRL::ComPtr<IMFMediaSource>& source) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!reader_.Get());
 
-  ScopedComPtr<IMFAttributes> attributes;
+  Microsoft::WRL::ComPtr<IMFAttributes> attributes;
   MFCreateAttributes(attributes.GetAddressOf(), 1);
   DCHECK(attributes.Get());
 
@@ -229,7 +228,7 @@ void VideoCaptureDeviceMFWin::AllocateAndStart(
     if (SUCCEEDED(hr)) {
       const CapabilityWin found_capability =
           GetBestMatchedCapability(params.requested_format, capabilities);
-      ScopedComPtr<IMFMediaType> type;
+      Microsoft::WRL::ComPtr<IMFMediaType> type;
       hr = reader_->GetNativeMediaType(kFirstVideoStream,
                                        found_capability.stream_index,
                                        type.GetAddressOf());
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 06fcdb311ee..93534f9dfb4 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
@@ -12,13 +12,13 @@
 #include <mfidl.h>
 #include <mfreadwrite.h>
 #include <stdint.h>
+#include <wrl/client.h>
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/sequence_checker.h"
 #include "base/synchronization/lock.h"
-#include "base/win/scoped_comptr.h"
 #include "media/capture/capture_export.h"
 #include "media/capture/video/video_capture_device.h"
 
@@ -44,7 +44,7 @@ class CAPTURE_EXPORT VideoCaptureDeviceMFWin : public VideoCaptureDevice {
   ~VideoCaptureDeviceMFWin() override;
 
   // Opens the device driver for this device.
-  bool Init(const base::win::ScopedComPtr<IMFMediaSource>& source);
+  bool Init(const Microsoft::WRL::ComPtr<IMFMediaSource>& source);
 
   // VideoCaptureDevice implementation.
   void AllocateAndStart(
@@ -63,12 +63,12 @@ class CAPTURE_EXPORT VideoCaptureDeviceMFWin : public VideoCaptureDevice {
   void OnError(const base::Location& from_here, HRESULT hr);
 
   VideoCaptureDeviceDescriptor descriptor_;
-  base::win::ScopedComPtr<IMFActivate> device_;
+  Microsoft::WRL::ComPtr<IMFActivate> device_;
   scoped_refptr<MFReaderCallback> callback_;
 
   base::Lock lock_;  // Used to guard the below variables.
   std::unique_ptr<VideoCaptureDevice::Client> client_;
-  base::win::ScopedComPtr<IMFSourceReader> reader_;
+  Microsoft::WRL::ComPtr<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 f0c76738a1b..e1e9ac72d22 100644
--- a/chromium/media/capture/video/win/video_capture_device_win.cc
+++ b/chromium/media/capture/video/win/video_capture_device_win.cc
@@ -19,8 +19,8 @@
 #include "media/base/timestamp_constants.h"
 #include "media/capture/video/blob_utils.h"
 
+using Microsoft::WRL::ComPtr;
 using base::win::ScopedCoMem;
-using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace media {
@@ -40,7 +40,7 @@ namespace media {
 bool PinMatchesCategory(IPin* pin, REFGUID category) {
   DCHECK(pin);
   bool found = false;
-  ScopedComPtr<IKsPropertySet> ks_property;
+  ComPtr<IKsPropertySet> ks_property;
   HRESULT hr = pin->QueryInterface(IID_PPV_ARGS(&ks_property));
   if (SUCCEEDED(hr)) {
     GUID pin_category;
@@ -106,7 +106,7 @@ void VideoCaptureDeviceWin::GetDeviceCapabilityList(
     const std::string& device_id,
     bool query_detailed_frame_rates,
     CapabilityList* out_capability_list) {
-  base::win::ScopedComPtr<IBaseFilter> capture_filter;
+  ComPtr<IBaseFilter> capture_filter;
   HRESULT hr = VideoCaptureDeviceWin::GetDeviceFilter(
       device_id, capture_filter.GetAddressOf());
   if (!capture_filter.Get()) {
@@ -115,9 +115,8 @@ void VideoCaptureDeviceWin::GetDeviceCapabilityList(
     return;
   }
 
-  base::win::ScopedComPtr<IPin> output_capture_pin(
-      VideoCaptureDeviceWin::GetPin(capture_filter.Get(), PINDIR_OUTPUT,
-                                    PIN_CATEGORY_CAPTURE, GUID_NULL));
+  ComPtr<IPin> output_capture_pin(VideoCaptureDeviceWin::GetPin(
+      capture_filter.Get(), PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE, GUID_NULL));
   if (!output_capture_pin.Get()) {
     DLOG(ERROR) << "Failed to get capture output pin";
     return;
@@ -129,11 +128,11 @@ void VideoCaptureDeviceWin::GetDeviceCapabilityList(
 
 // static
 void VideoCaptureDeviceWin::GetPinCapabilityList(
-    base::win::ScopedComPtr<IBaseFilter> capture_filter,
-    base::win::ScopedComPtr<IPin> output_capture_pin,
+    ComPtr<IBaseFilter> capture_filter,
+    ComPtr<IPin> output_capture_pin,
     bool query_detailed_frame_rates,
     CapabilityList* out_capability_list) {
-  ScopedComPtr<IAMStreamConfig> stream_config;
+  ComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin.CopyTo(stream_config.GetAddressOf());
   if (FAILED(hr)) {
     DLOG(ERROR) << "Failed to get IAMStreamConfig interface from "
@@ -143,7 +142,7 @@ void VideoCaptureDeviceWin::GetPinCapabilityList(
   }
 
   // Get interface used for getting the frame rate.
-  ScopedComPtr<IAMVideoControl> video_control;
+  ComPtr<IAMVideoControl> video_control;
   hr = capture_filter.CopyTo(video_control.GetAddressOf());
 
   int count = 0, size = 0;
@@ -224,13 +223,13 @@ HRESULT VideoCaptureDeviceWin::GetDeviceFilter(const std::string& device_id,
                                                IBaseFilter** filter) {
   DCHECK(filter);
 
-  ScopedComPtr<ICreateDevEnum> dev_enum;
+  ComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = ::CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
                                   IID_PPV_ARGS(&dev_enum));
   if (FAILED(hr))
     return hr;
 
-  ScopedComPtr<IEnumMoniker> enum_moniker;
+  ComPtr<IEnumMoniker> enum_moniker;
   hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
                                        enum_moniker.GetAddressOf(), 0);
   // CreateClassEnumerator returns S_FALSE on some Windows OS
@@ -238,11 +237,11 @@ HRESULT VideoCaptureDeviceWin::GetDeviceFilter(const std::string& device_id,
   if (hr != S_OK)
     return hr;
 
-  ScopedComPtr<IBaseFilter> capture_filter;
-  for (ScopedComPtr<IMoniker> moniker;
+  ComPtr<IBaseFilter> capture_filter;
+  for (ComPtr<IMoniker> moniker;
        enum_moniker->Next(1, moniker.GetAddressOf(), NULL) == S_OK;
        moniker.Reset()) {
-    ScopedComPtr<IPropertyBag> prop_bag;
+    ComPtr<IPropertyBag> prop_bag;
     hr = moniker->BindToStorage(0, 0, IID_PPV_ARGS(&prop_bag));
     if (FAILED(hr))
       continue;
@@ -281,12 +280,12 @@ HRESULT VideoCaptureDeviceWin::GetDeviceFilter(const std::string& device_id,
 // Finds an IPin on an IBaseFilter given the direction, Category and/or Major
 // Type. If either |category| or |major_type| are GUID_NULL, they are ignored.
 // static
-ScopedComPtr<IPin> VideoCaptureDeviceWin::GetPin(IBaseFilter* filter,
-                                                 PIN_DIRECTION pin_dir,
-                                                 REFGUID category,
-                                                 REFGUID major_type) {
-  ScopedComPtr<IPin> pin;
-  ScopedComPtr<IEnumPins> pin_enum;
+ComPtr<IPin> VideoCaptureDeviceWin::GetPin(IBaseFilter* filter,
+                                           PIN_DIRECTION pin_dir,
+                                           REFGUID category,
+                                           REFGUID major_type) {
+  ComPtr<IPin> pin;
+  ComPtr<IEnumPins> pin_enum;
   HRESULT hr = filter->EnumPins(pin_enum.GetAddressOf());
   if (pin_enum.Get() == NULL)
     return pin;
@@ -472,7 +471,7 @@ bool VideoCaptureDeviceWin::Init() {
   // require certain filters upstream from the WDM Video Capture filter, such as
   // a TV Tuner filter or an Analog Video Crossbar filter. We try using the more
   // prevalent MEDIATYPE_Interleaved first.
-  base::win::ScopedComPtr<IAMStreamConfig> stream_config;
+  ComPtr<IAMStreamConfig> stream_config;
 
   hr = capture_graph_builder_->FindInterface(
       &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved, capture_filter_.Get(),
@@ -506,7 +505,7 @@ void VideoCaptureDeviceWin::AllocateAndStart(
       std::min(params.requested_format.frame_rate,
                found_capability.supported_format.frame_rate);
 
-  ScopedComPtr<IAMStreamConfig> stream_config;
+  ComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.CopyTo(stream_config.GetAddressOf());
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Can't get the Capture format settings", hr);
@@ -795,7 +794,7 @@ void VideoCaptureDeviceWin::SetPhotoOptions(
 }
 
 bool VideoCaptureDeviceWin::InitializeVideoAndCameraControls() {
-  base::win::ScopedComPtr<IKsTopologyInfo> info;
+  ComPtr<IKsTopologyInfo> info;
   HRESULT hr = capture_filter_.CopyTo(info.GetAddressOf());
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to obtain the topology info.", hr);
@@ -876,7 +875,7 @@ void VideoCaptureDeviceWin::SetAntiFlickerInCaptureFilter(
       power_line_frequency != media::PowerLineFrequency::FREQUENCY_60HZ) {
     return;
   }
-  ScopedComPtr<IKsPropertySet> ks_propset;
+  ComPtr<IKsPropertySet> ks_propset;
   DWORD type_support = 0;
   HRESULT hr;
   if (SUCCEEDED(hr = capture_filter_.CopyTo(ks_propset.GetAddressOf())) &&
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 77ca33ccfd4..33166090691 100644
--- a/chromium/media/capture/video/win/video_capture_device_win.h
+++ b/chromium/media/capture/video/win/video_capture_device_win.h
@@ -13,6 +13,7 @@
 #include <dshow.h>
 #include <stdint.h>
 #include <vidcap.h>
+#include <wrl/client.h>
 
 #include <map>
 #include <string>
@@ -20,7 +21,6 @@
 #include "base/containers/queue.h"
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
-#include "base/win/scoped_comptr.h"
 #include "media/capture/video/video_capture_device.h"
 #include "media/capture/video/win/capability_list_win.h"
 #include "media/capture/video/win/sink_filter_win.h"
@@ -61,16 +61,16 @@ class VideoCaptureDeviceWin : public VideoCaptureDevice,
                                       bool query_detailed_frame_rates,
                                       CapabilityList* out_capability_list);
   static void GetPinCapabilityList(
-      base::win::ScopedComPtr<IBaseFilter> capture_filter,
-      base::win::ScopedComPtr<IPin> output_capture_pin,
+      Microsoft::WRL::ComPtr<IBaseFilter> capture_filter,
+      Microsoft::WRL::ComPtr<IPin> output_capture_pin,
       bool query_detailed_frame_rates,
       CapabilityList* out_capability_list);
   static HRESULT GetDeviceFilter(const std::string& device_id,
                                  IBaseFilter** filter);
-  static base::win::ScopedComPtr<IPin> GetPin(IBaseFilter* filter,
-                                              PIN_DIRECTION pin_dir,
-                                              REFGUID category,
-                                              REFGUID major_type);
+  static Microsoft::WRL::ComPtr<IPin> GetPin(IBaseFilter* filter,
+                                             PIN_DIRECTION pin_dir,
+                                             REFGUID category,
+                                             REFGUID major_type);
   static VideoPixelFormat TranslateMediaSubtypeToPixelFormat(
       const GUID& sub_type);
 
@@ -116,14 +116,14 @@ class VideoCaptureDeviceWin : public VideoCaptureDevice,
   InternalState state_;
   std::unique_ptr<VideoCaptureDevice::Client> client_;
 
-  base::win::ScopedComPtr<IBaseFilter> capture_filter_;
+  Microsoft::WRL::ComPtr<IBaseFilter> capture_filter_;
 
-  base::win::ScopedComPtr<IGraphBuilder> graph_builder_;
-  base::win::ScopedComPtr<ICaptureGraphBuilder2> capture_graph_builder_;
+  Microsoft::WRL::ComPtr<IGraphBuilder> graph_builder_;
+  Microsoft::WRL::ComPtr<ICaptureGraphBuilder2> capture_graph_builder_;
 
-  base::win::ScopedComPtr<IMediaControl> media_control_;
-  base::win::ScopedComPtr<IPin> input_sink_pin_;
-  base::win::ScopedComPtr<IPin> output_capture_pin_;
+  Microsoft::WRL::ComPtr<IMediaControl> media_control_;
+  Microsoft::WRL::ComPtr<IPin> input_sink_pin_;
+  Microsoft::WRL::ComPtr<IPin> output_capture_pin_;
 
   scoped_refptr<SinkFilter> sink_filter_;
 
@@ -132,8 +132,8 @@ class VideoCaptureDeviceWin : public VideoCaptureDevice,
 
   VideoCaptureFormat capture_format_;
 
-  base::win::ScopedComPtr<ICameraControl> camera_control_;
-  base::win::ScopedComPtr<IVideoProcAmp> video_control_;
+  Microsoft::WRL::ComPtr<ICameraControl> camera_control_;
+  Microsoft::WRL::ComPtr<IVideoProcAmp> video_control_;
   // These flags keep the manual/auto mode between cycles of SetPhotoOptions().
   bool white_balance_mode_manual_;
   bool exposure_mode_manual_;