Move V4L2 code into a webcam helper class.

This will make it simpler to add new webcam interface types.

BUG=None

Review URL: https://codereview.chromium.org/1136883004

Cr-Commit-Position: refs/heads/master@{#329922}

extensions/browser/api/webcam_private/v4l2_webcam.cc

+// Copyright 2015 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 "extensions/browser/api/webcam_private/v4l2_webcam.h"
+
+#include <fcntl.h>
+#include <linux/uvcvideo.h>
+#include <linux/videodev2.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#include "base/posix/eintr_wrapper.h"
+
+#define V4L2_CID_PAN_SPEED (V4L2_CID_CAMERA_CLASS_BASE+32)
+#define V4L2_CID_TILT_SPEED (V4L2_CID_CAMERA_CLASS_BASE+33)
+#define V4L2_CID_PANTILT_CMD (V4L2_CID_CAMERA_CLASS_BASE+34)
+
+// GUID of the Extension Unit for Logitech CC3300e motor control:
+// {212de5ff-3080-2c4e-82d9-f587d00540bd}
+#define UVC_GUID_LOGITECH_CC3000E_MOTORS          \
+ {0x21, 0x2d, 0xe5, 0xff, 0x30, 0x80, 0x2c, 0x4e, \
+  0x82, 0xd9, 0xf5, 0x87, 0xd0, 0x05, 0x40, 0xbd}
+
+#define LOGITECH_MOTORCONTROL_PANTILT_CMD 2
+
+namespace {
+const int kLogitechMenuIndexGoHome = 2;
+
+const uvc_menu_info kLogitechCmdMenu[] = {
+  {1, "Set Preset"}, {2, "Get Preset"}, {3, "Go Home"}
+};
+
+const uvc_xu_control_mapping kLogitechCmdMapping = {
+  V4L2_CID_PANTILT_CMD,
+  "Pan/Tilt Go",
+  UVC_GUID_LOGITECH_CC3000E_MOTORS,
+  LOGITECH_MOTORCONTROL_PANTILT_CMD,
+  8,
+  0,
+  V4L2_CTRL_TYPE_MENU,
+  UVC_CTRL_DATA_TYPE_ENUM,
+  const_cast<uvc_menu_info*>(&kLogitechCmdMenu[0]),
+  arraysize(kLogitechCmdMenu),
+};
+}  // namespace
+
+namespace extensions {
+
+V4L2Webcam::V4L2Webcam(const std::string& device_id) : device_id_(device_id) {
+}
+
+V4L2Webcam::~V4L2Webcam() {
+}
+
+bool V4L2Webcam::Open() {
+  fd_.reset(HANDLE_EINTR(open(device_id_.c_str(), 0)));
+  return fd_.is_valid();
+}
+
+bool V4L2Webcam::EnsureLogitechCommandsMapped() {
+  int res =
+      HANDLE_EINTR(ioctl(fd_.get(), UVCIOC_CTRL_MAP, &kLogitechCmdMapping));
+  // If mapping is successful or it's already mapped, this is a Logitech
+  // camera.
+  // NOTE: On success, occasionally EFAULT is returned.  On a real error,
+  // ENOMEM, EPERM, EINVAL, or EOVERFLOW should be returned.
+  return res >= 0 || errno == EEXIST || errno == EFAULT;
+}
+
+bool V4L2Webcam::SetWebcamParameter(int fd, uint32_t control_id, int value) {
+  struct v4l2_control v4l2_ctrl = {control_id, value};
+  int res = HANDLE_EINTR(ioctl(fd, VIDIOC_S_CTRL, &v4l2_ctrl)) >= 0;
+  return res >= 0;
+}
+
+bool V4L2Webcam::GetWebcamParameter(int fd, uint32_t control_id, int* value) {
+  struct v4l2_control v4l2_ctrl = {control_id};
+
+  if (HANDLE_EINTR(ioctl(fd, VIDIOC_G_CTRL, &v4l2_ctrl)))
+    return false;
+
+  *value = v4l2_ctrl.value;
+  return true;
+}
+
+void V4L2Webcam::Reset(bool pan, bool tilt, bool zoom) {
+  if (pan || tilt) {
+    if (EnsureLogitechCommandsMapped()) {
+      SetWebcamParameter(fd_.get(), V4L2_CID_PANTILT_CMD,
+                         kLogitechMenuIndexGoHome);
+    } else {
+      if (pan) {
+        struct v4l2_control v4l2_ctrl = {V4L2_CID_PAN_RESET};
+        HANDLE_EINTR(ioctl(fd_.get(), VIDIOC_S_CTRL, &v4l2_ctrl));
+      }
+
+      if (tilt) {
+        struct v4l2_control v4l2_ctrl = {V4L2_CID_TILT_RESET};
+        HANDLE_EINTR(ioctl(fd_.get(), VIDIOC_S_CTRL, &v4l2_ctrl));
+      }
+    }
+  }
+
+  if (zoom) {
+    const int kDefaultZoom = 100;
+    SetWebcamParameter(fd_.get(), V4L2_CID_ZOOM_ABSOLUTE, kDefaultZoom);
+  }
+}
+
+bool V4L2Webcam::GetPan(int* value) {
+  return GetWebcamParameter(fd_.get(), V4L2_CID_PAN_ABSOLUTE, value);
+}
+
+bool V4L2Webcam::GetTilt(int* value) {
+  return GetWebcamParameter(fd_.get(), V4L2_CID_TILT_ABSOLUTE, value);
+}
+
+bool V4L2Webcam::GetZoom(int* value) {
+  return GetWebcamParameter(fd_.get(), V4L2_CID_ZOOM_ABSOLUTE, value);
+}
+
+bool V4L2Webcam::SetPan(int value) {
+  return SetWebcamParameter(fd_.get(), V4L2_CID_PAN_ABSOLUTE, value);
+}
+
+bool V4L2Webcam::SetTilt(int value) {
+  return SetWebcamParameter(fd_.get(), V4L2_CID_TILT_ABSOLUTE, value);
+}
+
+bool V4L2Webcam::SetZoom(int value) {
+  return SetWebcamParameter(fd_.get(), V4L2_CID_ZOOM_ABSOLUTE, value);
+}
+
+bool V4L2Webcam::SetPanDirection(PanDirection direction) {
+  int direction_value = 0;
+  switch (direction) {
+    case PAN_STOP:
+      direction_value = 0;
+      break;
+
+    case PAN_RIGHT:
+      direction_value = 1;
+      break;
+
+    case PAN_LEFT:
+      direction_value = -1;
+      break;
+  }
+  return SetWebcamParameter(fd_.get(), V4L2_CID_PAN_SPEED, direction_value);
+}
+
+bool V4L2Webcam::SetTiltDirection(TiltDirection direction) {
+  int direction_value = 0;
+  switch (direction) {
+    case TILT_STOP:
+      direction_value = 0;
+      break;
+
+    case TILT_UP:
+      direction_value = 1;
+      break;
+
+    case TILT_DOWN:
+      direction_value = -1;
+      break;
+  }
+  return SetWebcamParameter(fd_.get(), V4L2_CID_TILT_SPEED, direction_value);
+}
+
+}  // namespace extensions

extensions/browser/api/webcam_private/v4l2_webcam.h

+// Copyright 2015 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 EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_V4L2_WEBCAM_H_
+#define EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_V4L2_WEBCAM_H_
+
+#include "extensions/browser/api/webcam_private/webcam.h"
+
+#include "base/files/scoped_file.h"
+
+namespace extensions {
+
+class V4L2Webcam : public Webcam {
+ public:
+  V4L2Webcam(const std::string& device_id);
+  ~V4L2Webcam() override;
+
+  bool Open();
+
+ private:
+  bool EnsureLogitechCommandsMapped();
+  bool SetWebcamParameter(int fd, uint32_t control_id, int value);
+  bool GetWebcamParameter(int fd, uint32_t control_id, int* value);
+
+  // Webcam:
+  void Reset(bool pan, bool tilt, bool zoom) override;
+  bool GetPan(int* value) override;
+  bool GetTilt(int* value) override;
+  bool GetZoom(int* value) override;
+  bool SetPan(int value) override;
+  bool SetTilt(int value) override;
+  bool SetZoom(int value) override;
+  bool SetPanDirection(PanDirection direction) override;
+  bool SetTiltDirection(TiltDirection direction) override;
+
+  const std::string device_id_;
+  base::ScopedFD fd_;
+
+  DISALLOW_COPY_AND_ASSIGN(V4L2Webcam);
+};
+
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_V4L2_WEBCAM_H_

extensions/browser/api/webcam_private/webcam.cc

+// Copyright 2015 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 "extensions/browser/api/webcam_private/webcam.h"
+
+namespace extensions {
+
+Webcam::Webcam() {}
+Webcam::~Webcam() {}
+
+}  // namespace extensions

extensions/browser/api/webcam_private/webcam.h

+// Copyright 2015 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 EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_WEBCAM_H_
+#define EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_WEBCAM_H_
+
+#include <set>
+#include <string>
+
+#include "base/macros.h"
+
+namespace extensions {
+
+class Webcam {
+ public:
+  enum PanDirection {
+    PAN_LEFT,
+    PAN_RIGHT,
+    PAN_STOP,
+  };
+
+  enum TiltDirection {
+    TILT_UP,
+    TILT_DOWN,
+    TILT_STOP,
+  };
+
+  Webcam();
+  virtual ~Webcam();
+
+  virtual void Reset(bool pan, bool tilt, bool zoom) = 0;
+  virtual bool GetPan(int* value) = 0;
+  virtual bool GetTilt(int* value) = 0;
+  virtual bool GetZoom(int* value) = 0;
+  virtual bool SetPan(int value) = 0;
+  virtual bool SetTilt(int value) = 0;
+  virtual bool SetZoom(int value) = 0;
+  virtual bool SetPanDirection(PanDirection direction) = 0;
+  virtual bool SetTiltDirection(TiltDirection direction) = 0;
+
+  void AddExtensionRef(const std::string& extension_id) {
+    extension_refs_.insert(extension_id);
+  }
+
+  void RemoveExtensionRef(const std::string& extension_id) {
+    extension_refs_.erase(extension_id);
+  }
+
+  bool ShouldDelete() {
+    return extension_refs_.empty();
+  }
+
+ private:
+  std::set<std::string> extension_refs_;
+
+  DISALLOW_COPY_AND_ASSIGN(Webcam);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_WEBCAM_H_

extensions/browser/api/webcam_private/webcam_private_api.h

@@ -5,12 +5,65 @@
 #ifndef EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_WEBCAM_PRIVATE_API_H_
 #define EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_WEBCAM_PRIVATE_API_H_
 
+#include <map>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/scoped_observer.h"
+#include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/extension_function.h"
+#include "extensions/browser/process_manager_observer.h"
 
 class Profile;
 
 namespace extensions {
 
+class ProcessManager;
+class Webcam;
+
+class WebcamPrivateAPI : public BrowserContextKeyedAPI,
+                         public ProcessManagerObserver {
+ public:
+  static BrowserContextKeyedAPIFactory<WebcamPrivateAPI>* GetFactoryInstance();
+
+  // Convenience method to get the WebcamPrivateAPI for a BrowserContext.
+  static WebcamPrivateAPI* Get(content::BrowserContext* context);
+
+  explicit WebcamPrivateAPI(content::BrowserContext* context);
+  ~WebcamPrivateAPI() override;
+
+  Webcam* GetWebcam(const std::string& extension_id,
+                    const std::string& webcam_id);
+
+ private:
+  friend class BrowserContextKeyedAPIFactory<WebcamPrivateAPI>;
+
+  bool GetDeviceId(const std::string& extension_id,
+                   const std::string& webcam_id,
+                   std::string* device_id);
+
+  // ProcessManagerObserver:
+  void OnBackgroundHostClose(const std::string& extension_id) override;
+
+  // BrowserContextKeyedAPI:
+  static const char* service_name() {
+    return "WebcamPrivateAPI";
+  }
+  static const bool kServiceIsNULLWhileTesting = true;
+  static const bool kServiceRedirectedInIncognito = true;
+
+  content::BrowserContext* const browser_context_;
+  ScopedObserver<ProcessManager, ProcessManagerObserver>
+      process_manager_observer_;
+
+  std::map<std::string, linked_ptr<Webcam>> webcams_;
+
+  base::WeakPtrFactory<WebcamPrivateAPI> weak_ptr_factory_;
+};
+
+template <>
+void BrowserContextKeyedAPIFactory<WebcamPrivateAPI>
+    ::DeclareFactoryDependencies();
+
 class WebcamPrivateSetFunction : public SyncExtensionFunction {
  public:
   WebcamPrivateSetFunction();

extensions/browser/browser_context_keyed_service_factories.cc

@@ -24,6 +24,7 @@
 #include "extensions/browser/api/system_info/system_info_api.h"
 #include "extensions/browser/api/usb/usb_event_router.h"
 #include "extensions/browser/api/vpn_provider/vpn_service_factory.h"
+#include "extensions/browser/api/webcam_private/webcam_private_api.h"
 #include "extensions/browser/extension_message_filter.h"
 #include "extensions/browser/extension_prefs_factory.h"
 #include "extensions/browser/process_manager_factory.h"
@@ -62,6 +63,9 @@ void EnsureBrowserContextKeyedServiceFactoriesBuilt() {
   StorageFrontend::GetFactoryInstance();
   SystemInfoAPI::GetFactoryInstance();
   UsbEventRouter::GetFactoryInstance();
+#if defined(OS_CHROMEOS)
+  WebcamPrivateAPI::GetFactoryInstance();
+#endif
 }
 
 }  // namespace extensions

extensions/extensions.gypi

@@ -502,8 +502,6 @@
       'browser/api/web_request/web_request_permissions.h',
       'browser/api/web_request/web_request_time_tracker.cc',
       'browser/api/web_request/web_request_time_tracker.h',
-      'browser/api/webcam_private/webcam_private_api.h',
-      'browser/api/webcam_private/webcam_private_api_chromeos.cc',
       'browser/api_activity_monitor.h',
       'browser/app_sorting.h',
       'browser/app_window/app_delegate.h',
@@ -799,6 +797,12 @@
       'browser/api/vpn_provider/vpn_service.cc',
       'browser/api/vpn_provider/vpn_service.h',
       'browser/api/vpn_provider/vpn_service_factory.h',
+      'browser/api/webcam_private/v4l2_webcam.h',
+      'browser/api/webcam_private/v4l2_webcam.cc',
+      'browser/api/webcam_private/webcam.h',
+      'browser/api/webcam_private/webcam.cc',
+      'browser/api/webcam_private/webcam_private_api.h',
+      'browser/api/webcam_private/webcam_private_api_chromeos.cc',
     ],
     'extensions_browser_sources_nonchromeos': [
       'browser/api/audio/audio_service.cc',