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 <algorithm>
 #include <utility>
 
 #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/pixel_format_utils.h"
 #include "media/capture/video/chromeos/video_capture_device_arc_chromeos.h"
-#include "mojo/edk/embedder/embedder.h"
-#include "mojo/edk/embedder/incoming_broker_client_invitation.h"
-#include "mojo/edk/embedder/named_platform_handle.h"
-#include "mojo/edk/embedder/named_platform_handle_utils.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(
     scoped_refptr<base::SingleThreadTaskRunner> ipc_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),
       ipc_task_runner_(std::move(ipc_task_runner)),
       camera_module_callbacks_(this) {
   DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
 CameraHalDelegate::~CameraHalDelegate() {}
 
-bool CameraHalDelegate::StartCameraModuleIpc() {
-  // Non-blocking socket handle.
-  mojo::edk::ScopedPlatformHandle socket_handle = mojo::edk::CreateClientHandle(
-      mojo::edk::NamedPlatformHandle(kArcCamera3SocketPath));
+void CameraHalDelegate::RegisterCameraClient() {
+  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;
-  }
-  std::unique_ptr<mojo::edk::IncomingBrokerClientInvitation> invitation =
-      mojo::edk::IncomingBrokerClientInvitation::Accept(
-          mojo::edk::ConnectionParams(mojo::edk::TransportProtocol::kLegacy,
-                                      std::move(parent_pipe)));
-  mojo::ScopedMessagePipeHandle child_pipe =
-      invitation->ExtractMessagePipe(token);
-  DCHECK(child_pipe.is_valid());
-
+void CameraHalDelegate::SetCameraModule(
+    arc::mojom::CameraModulePtrInfo camera_module_ptr_info) {
   camera_module_ =
-      mojo::MakeProxy(mojo::InterfacePtrInfo<arc::mojom::CameraModule>(
-                          std::move(child_pipe), 0u),
-                      ipc_task_runner_);
-
-  VLOG(1) << "Camera module IPC connection established";
-
-  return true;
+      mojo::MakeProxy(std::move(camera_module_ptr_info), ipc_task_runner_);
+  camera_module_set_.Signal();
+  ipc_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&CameraHalDelegate::SetConnectionErrorHandlerOnModuleThread,
+                 this));
 }
 
 void CameraHalDelegate::Reset() {
   ipc_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CameraHalDelegate::ResetMojoInterfaceOnModuleThread, this));
 }
 
 std::unique_ptr<VideoCaptureDevice> CameraHalDelegate::CreateDevice(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner_for_screen_observer,
     const VideoCaptureDeviceDescriptor& device_descriptor) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  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(
       std::move(task_runner_for_screen_observer), device_descriptor, this));
   return capture_device;
 }
 
 void CameraHalDelegate::GetSupportedFormats(
     const VideoCaptureDeviceDescriptor& device_descriptor,
     VideoCaptureFormats* supported_formats) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
+  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()) {
     LOG(ERROR) << "Invalid camera_id: " << camera_id;
     return;
   }
   const arc::mojom::CameraInfoPtr& camera_info = camera_info_[camera_id];
@@ skipping 36 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_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  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 21 matching lines @@
   }
   // TODO(jcliang): Remove this after JS API supports query camera facing
   // (http://crbug.com/543997).
   std::sort(device_descriptors->begin(), device_descriptors->end());
 }
 
 void CameraHalDelegate::GetCameraInfo(int32_t camera_id,
                                       const GetCameraInfoCallback& callback) {
   // This method may be called on any thread.  Currently this method is used by
   // CameraDeviceDelegate to query camera info.
+  camera_module_set_.Wait();
   ipc_task_runner_->PostTask(
       FROM_HERE, base::Bind(&CameraHalDelegate::GetCameraInfoOnModuleThread,
                             this, camera_id, callback));
 }
 
 void CameraHalDelegate::OpenDevice(
     int32_t camera_id,
     arc::mojom::Camera3DeviceOpsRequest device_ops_request,
     const OpenDeviceCallback& callback) {
   // This method may be called on any thread.  Currently this method is used by
   // CameraDeviceDelegate to open a camera device.
+  camera_module_set_.Wait();
   ipc_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CameraHalDelegate::OpenDeviceOnModuleThread, this, camera_id,
                  base::Passed(&device_ops_request), callback));
 }
 
-void CameraHalDelegate::StartForTesting(arc::mojom::CameraModulePtrInfo info) {
-  camera_module_.Bind(std::move(info), ipc_task_runner_);
+void CameraHalDelegate::SetConnectionErrorHandlerOnModuleThread() {
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
+  DCHECK(camera_module_set_.IsSignaled());
+  camera_module_.set_connection_error_handler(base::Bind(
+      &CameraHalDelegate::HandleMojoConnectionErrorOnModuleThread, this));
+}
+
+void CameraHalDelegate::HandleMojoConnectionErrorOnModuleThread() {
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
+  camera_module_.reset();
+  if (camera_module_callbacks_.is_bound()) {
+    camera_module_callbacks_.Unbind();
+  }
+  camera_module_set_.Reset();
 }
 
 void CameraHalDelegate::ResetMojoInterfaceOnModuleThread() {
   DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   camera_module_.reset();
   if (camera_module_callbacks_.is_bound()) {
     camera_module_callbacks_.Close();
   }
 }
 
@@ skipping 96 matching lines @@
 
 // CameraModuleCallbacks implementations.
 void CameraHalDelegate::CameraDeviceStatusChange(
     int32_t camera_id,
     arc::mojom::CameraDeviceStatus new_status) {
   DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   // TODO(jcliang): Handle status change for external cameras.
 }
 
 }  // namespace media