media: add ArcCamera3Service Mojo service

media/capture/video/chromeos/camera_hal_delegate.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/chromeos/camera_hal_delegate.h"
 
 #include <fcntl.h>
 #include <sys/uio.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/strings/string_piece.h"
 #include "media/capture/video/chromeos/camera_metadata_utils.h"
 #include "media/capture/video/chromeos/video_capture_device_arc_chromeos.h"
-#include "mojo/edk/embedder/embedder.h"
-#include "mojo/edk/embedder/named_platform_handle.h"
-#include "mojo/edk/embedder/named_platform_handle_utils.h"
-#include "mojo/edk/embedder/pending_process_connection.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"
 
 namespace media {
 
 namespace {
 
 const base::StringPiece kArcCamera3SocketPath("/var/run/camera/camera3.sock");
 
 const base::TimeDelta kEventWaitTimeoutMs =
     base::TimeDelta::FromMilliseconds(3000);
 
 }  // namespace
 
+CameraHalDelegate::LocalCameraClient::LocalCameraClient(
+    scoped_refptr<CameraHalDelegate> camera_hal_delegate)
+    : camera_hal_delegate_(camera_hal_delegate) {}
+
+void CameraHalDelegate::LocalCameraClient::NotifyCameraHalRegistered(
+    arc::mojom::CameraModulePtr camera_module) {
+  camera_hal_delegate_->SetCameraModule(camera_module.PassInterface());
+}
+
 CameraHalDelegate::CameraHalDelegate(
     const scoped_refptr<base::SingleThreadTaskRunner> module_task_runner)
-    : builtin_camera_info_updated_(
+    : camera_module_set_(base::WaitableEvent::ResetPolicy::MANUAL,
+                         base::WaitableEvent::InitialState::NOT_SIGNALED),
+      builtin_camera_info_updated_(
           base::WaitableEvent::ResetPolicy::MANUAL,
           base::WaitableEvent::InitialState::NOT_SIGNALED),
       num_builtin_cameras_(0),
       module_task_runner_(module_task_runner),
       camera_module_callbacks_(this) {
   // We need to detach |thread_checker_| here because constructor is called on
   // UI thread while the VideoCaptureDeviceFactory methods are called on capture
   // thread.
   thread_checker_.DetachFromThread();
 }
 
 CameraHalDelegate::~CameraHalDelegate() {
   base::WaitableEvent interface_closed(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   module_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CameraHalDelegate::ResetMojoInterfaceOnModuleThread,
                  base::Unretained(this), base::Unretained(&interface_closed)));
   interface_closed.Wait();
 }
 
-bool CameraHalDelegate::StartCameraModuleIpc() {
-  // Non-blocking socket handle.
-  mojo::edk::ScopedPlatformHandle socket_handle = mojo::edk::CreateClientHandle(
-      mojo::edk::NamedPlatformHandle(kArcCamera3SocketPath));
+void CameraHalDelegate::Start() {
+  auto client_observer = base::MakeUnique<LocalCameraClient>(this);
+  ArcCamera3Service::GetInstance()->AddClientObserver(
+      std::move(client_observer));
+}
 
-  // Set socket to blocking
-  int flags = HANDLE_EINTR(fcntl(socket_handle.get().handle, F_GETFL));
-  if (flags == -1) {
-    PLOG(ERROR) << "fcntl(F_GETFL) failed: ";
-    return false;
-  }
-  if (HANDLE_EINTR(fcntl(socket_handle.get().handle, F_SETFL,
-                         flags & ~O_NONBLOCK)) == -1) {
-    PLOG(ERROR) << "fcntl(F_SETFL) failed: ";
-    return false;
-  }
-
-  const size_t kTokenSize = 32;
-  char token[kTokenSize] = {};
-  std::deque<mojo::edk::PlatformHandle> platform_handles;
-  ssize_t ret = mojo::edk::PlatformChannelRecvmsg(
-      socket_handle.get(), token, sizeof(token), &platform_handles, true);
-  if (ret == -1) {
-    PLOG(ERROR) << "PlatformChannelRecvmsg failed: ";
-    return false;
-  }
-  if (platform_handles.size() != 1) {
-    LOG(ERROR) << "Unexpected number of handles received, expected 1: "
-               << platform_handles.size();
-    return false;
-  }
-  mojo::edk::ScopedPlatformHandle parent_pipe(platform_handles.back());
-  platform_handles.pop_back();
-  if (!parent_pipe.is_valid()) {
-    LOG(ERROR) << "Invalid parent pipe";
-    return false;
-  }
-  mojo::edk::SetParentPipeHandle(std::move(parent_pipe));
-
-  mojo::ScopedMessagePipeHandle child_pipe =
-      mojo::edk::CreateChildMessagePipe(std::string(token, kTokenSize));
-
+void CameraHalDelegate::SetCameraModule(
+    arc::mojom::CameraModulePtrInfo camera_module_ptr_info) {
   camera_module_ =
-      mojo::MakeProxy(mojo::InterfacePtrInfo<arc::mojom::CameraModule>(
-                          std::move(child_pipe), 0u),
-                      module_task_runner_);
-
-  VLOG(1) << "Camera module IPC connection established";
-
-  return true;
+      mojo::MakeProxy(std::move(camera_module_ptr_info), module_task_runner_);
+  camera_module_set_.Signal();
+  module_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&CameraHalDelegate::SetConnectionErrorHandlerOnModuleThread,
+                 this));
 }
 
 std::unique_ptr<VideoCaptureDevice> CameraHalDelegate::CreateDevice(
     const scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     const VideoCaptureDeviceDescriptor& device_descriptor) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  camera_module_set_.Wait();
   std::unique_ptr<VideoCaptureDevice> capture_device;
   if (!UpdateBuiltInCameraInfo()) {
     return capture_device;
   }
   if (camera_info_.find(device_descriptor.device_id) == camera_info_.end()) {
     LOG(ERROR) << "Invalid camera device: " << device_descriptor.device_id;
     return capture_device;
   }
   capture_device.reset(new VideoCaptureDeviceArcChromeOS(
       ui_task_runner, device_descriptor, this));
   return capture_device;
 }
 
 void CameraHalDelegate::GetSupportedFormats(
     const VideoCaptureDeviceDescriptor& device_descriptor,
     VideoCaptureFormats* supported_formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  camera_module_set_.Wait();
   if (!UpdateBuiltInCameraInfo()) {
     return;
   }
   std::string camera_id = device_descriptor.device_id;
   if (camera_info_.find(camera_id) == camera_info_.end() ||
       camera_info_[camera_id].is_null()) {
     // The camera may be removed already or is not ready yet.
     VLOG(1) << "Invalid camera_id: " << camera_id;
     return;
   }
@@ skipping 50 matching lines @@
     VLOG(1) << "Supported format: " << width << "x" << height
             << " fps=" << max_fps << " format=" << cr_format;
     supported_formats->emplace_back(gfx::Size(width, height), max_fps,
                                     cr_format);
   }
 }
 
 void CameraHalDelegate::GetDeviceDescriptors(
     VideoCaptureDeviceDescriptors* device_descriptors) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  camera_module_set_.Wait();
 
   if (!UpdateBuiltInCameraInfo()) {
     return;
   }
   for (size_t id = 0; id < num_builtin_cameras_; ++id) {
     VideoCaptureDeviceDescriptor desc;
     std::string camera_id = std::to_string(id);
     const arc::mojom::CameraInfoPtr& camera_info = camera_info_[camera_id];
     if (!camera_info) {
       continue;
@@ skipping 18 matching lines @@
         // about malformed values.
     }
     device_descriptors->push_back(desc);
   }
 }
 
 void CameraHalDelegate::GetCameraInfo(int32_t camera_id,
                                       const GetCameraInfoCallback& callback) {
   // This method may be called on any thread.  Currently this method is used by
   // VideoCaptureDeviceArcChromeOS to query camera info.
+  camera_module_set_.Wait();
   module_task_runner_->PostTask(
       FROM_HERE, base::Bind(&CameraHalDelegate::GetCameraInfoOnModuleThread,
                             this, camera_id, callback));
 }
 
 void CameraHalDelegate::OpenDevice(int32_t camera_id,
                                    const OpenDeviceCallback& callback) {
   // This method may be called on any thread.  Currently this method is used by
   // VideoCaptureDeviceArcChromeOS to open a camera device.
+  camera_module_set_.Wait();
   module_task_runner_->PostTask(
       FROM_HERE, base::Bind(&CameraHalDelegate::OpenDeviceOnModuleThread, this,
                             camera_id, callback));
 }
 
+void CameraHalDelegate::SetConnectionErrorHandlerOnModuleThread() {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  DCHECK(camera_module_set_.IsSignaled());
+  camera_module_.set_connection_error_handler(base::Bind(
+      &CameraHalDelegate::HandleMojoConnectionErrorOnModuleThread, this));
+}
+
+void CameraHalDelegate::HandleMojoConnectionErrorOnModuleThread() {
+  DCHECK(module_task_runner_->BelongsToCurrentThread());
+  camera_module_.reset();
+  if (camera_module_callbacks_.is_bound()) {
+    camera_module_callbacks_.Unbind();
+  }
+  camera_module_set_.Reset();
+}
+
 void CameraHalDelegate::ResetMojoInterfaceOnModuleThread(
     base::WaitableEvent* interface_closed) {
   DCHECK(module_task_runner_->BelongsToCurrentThread());
   camera_module_.reset();
   if (camera_module_callbacks_.is_bound()) {
     camera_module_callbacks_.Unbind();
   }
   interface_closed->Signal();
 }
 
@@ skipping 96 matching lines @@
 
 // CameraModuleCallbacks implementations.
 void CameraHalDelegate::CameraDeviceStatusChange(
     int32_t camera_id,
     arc::mojom::CameraDeviceStatus new_status) {
   DCHECK(module_task_runner_->BelongsToCurrentThread());
   // TODO(jcliang): Handle status change for external cameras.
 }
 
 }  // namespace media