[Mojo Video Capture] Fix VideoCaptureManager exposing implementation details to clients

media/capture/video/video_capture_system_impl.cc

 // 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/video_capture_system.h"
+#include "media/capture/video/video_capture_system_impl.h"
 
 #include "media/base/bind_to_current_loop.h"
 
 namespace {
 
 // Compares two VideoCaptureFormat by checking smallest frame_size area, then
 // by _largest_ frame_rate. Used to order a VideoCaptureFormats vector so that
 // the first entry for a given resolution has the largest frame rate, as needed
 // by the ConsolidateCaptureFormats() method.
 bool IsCaptureFormatSmaller(const media::VideoCaptureFormat& format1,
@@ skipping 34 matching lines @@
   for (auto& format : *formats) {
     if (format.pixel_format != media::PIXEL_FORMAT_Y16)
       format.pixel_format = media::PIXEL_FORMAT_I420;
   }
 }
 
 }  // anonymous namespace
 
 namespace media {
 
-VideoCaptureSystem::VideoCaptureSystem(
+VideoCaptureSystemImpl::VideoCaptureSystemImpl(
     std::unique_ptr<VideoCaptureDeviceFactory> factory)
     : factory_(std::move(factory)) {
   thread_checker_.DetachFromThread();
 }
 
-VideoCaptureSystem::~VideoCaptureSystem() = default;
+VideoCaptureSystemImpl::~VideoCaptureSystemImpl() = default;
 
-void VideoCaptureSystem::GetDeviceInfosAsync(
+void VideoCaptureSystemImpl::GetDeviceInfosAsync(
     const DeviceInfoCallback& result_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Use of Unretained() is safe assuming that |result_callback| has ownership
   // of |this|.
   factory_->EnumerateDeviceDescriptors(media::BindToCurrentLoop(
-      base::Bind(&VideoCaptureSystem::OnDescriptorsReceived,
+      base::Bind(&VideoCaptureSystemImpl::OnDescriptorsReceived,
                  base::Unretained(this), result_callback)));
 }
 
 // Creates a VideoCaptureDevice object. Returns NULL if something goes wrong.
-std::unique_ptr<VideoCaptureDevice> VideoCaptureSystem::CreateDevice(
+std::unique_ptr<VideoCaptureDevice> VideoCaptureSystemImpl::CreateDevice(
     const std::string& device_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const VideoCaptureDeviceInfo* device_info = LookupDeviceInfoFromId(device_id);
   if (!device_info)
     return nullptr;
   return factory_->CreateDevice(device_info->descriptor);
 }
 
-void VideoCaptureSystem::OnDescriptorsReceived(
+void VideoCaptureSystemImpl::OnDescriptorsReceived(
     const DeviceInfoCallback& result_callback,
     std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // For devices for which we already have an entry in |devices_info_cache_|,
   // we do not want to query the |factory_| for supported formats again. We
   // simply copy them from |devices_info_cache_|.
   std::vector<VideoCaptureDeviceInfo> new_devices_info_cache;
   new_devices_info_cache.reserve(descriptors->size());
   for (const auto& descriptor : *descriptors) {
     if (auto* cached_info = LookupDeviceInfoFromId(descriptor.device_id)) {
       new_devices_info_cache.push_back(*cached_info);
     } else {
       // Query for supported formats in order to create the entry.
       VideoCaptureDeviceInfo device_info(descriptor);
       factory_->GetSupportedFormats(descriptor, &device_info.supported_formats);
       ConsolidateCaptureFormats(&device_info.supported_formats);
       new_devices_info_cache.push_back(device_info);
     }
   }
 
   devices_info_cache_.swap(new_devices_info_cache);
   result_callback.Run(devices_info_cache_);
 }
 
-const VideoCaptureDeviceInfo* VideoCaptureSystem::LookupDeviceInfoFromId(
+const VideoCaptureDeviceInfo* VideoCaptureSystemImpl::LookupDeviceInfoFromId(
     const std::string& device_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   auto iter = std::find_if(
       devices_info_cache_.begin(), devices_info_cache_.end(),
       [&device_id](const media::VideoCaptureDeviceInfo& device_info) {
         return device_info.descriptor.device_id == device_id;
       });
   if (iter == devices_info_cache_.end())
     return nullptr;
   return &(*iter);
 }
 
 }  // namespace media