extensions/browser/api/webcam_private/webcam_private_api_chromeos.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/api/webcam_private/webcam_private_api.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "content/public/browser/browser_context.h"
   9 #include "content/public/browser/media_device_id.h"
  10 #include "content/public/browser/resource_context.h"
  11 #include "extensions/browser/api/webcam_private/v4l2_webcam.h"
  12 #include "extensions/browser/api/webcam_private/visca_webcam.h"
  13 #include "extensions/browser/process_manager.h"
  14 #include "extensions/browser/process_manager_factory.h"
  15 #include "extensions/common/api/webcam_private.h"
  16
  17 namespace webcam_private = extensions::api::webcam_private;
  18
  19 namespace content {
  20 class BrowserContext;
  21 }  // namespace content
  22
  23 namespace {
  24 const char kPathInUse[] = "Path in use";
  25 const char kUnknownWebcam[] = "Unknown webcam id";
  26 }  // namespace
  27
  28 namespace extensions {
  29
  30 // static
  31 WebcamPrivateAPI* WebcamPrivateAPI::Get(content::BrowserContext* context) {
  32   return GetFactoryInstance()->Get(context);
  33 }
  34
  35 WebcamPrivateAPI::WebcamPrivateAPI(content::BrowserContext* context)
  36     : browser_context_(context),
  37       weak_ptr_factory_(this) {
  38   webcam_resource_manager_.reset(
  39       new ApiResourceManager<WebcamResource>(context));
  40 }
  41
  42 WebcamPrivateAPI::~WebcamPrivateAPI() {
  43 }
  44
  45 Webcam* WebcamPrivateAPI::GetWebcam(const std::string& extension_id,
  46                                     const std::string& webcam_id) {
  47   WebcamResource* webcam_resource = FindWebcamResource(extension_id, webcam_id);
  48   if (webcam_resource)
  49     return webcam_resource->GetWebcam();
  50
  51   std::string device_id;
  52   GetDeviceId(extension_id, webcam_id, &device_id);
  53   V4L2Webcam* v4l2_webcam(new V4L2Webcam(device_id));
  54   if (!v4l2_webcam->Open()) {
  55     return nullptr;
  56   }
  57
  58   webcam_resource_manager_->Add(
  59       new WebcamResource(extension_id, v4l2_webcam, webcam_id));
  60
  61   return v4l2_webcam;
  62 }
  63
  64 bool WebcamPrivateAPI::OpenSerialWebcam(
  65     const std::string& extension_id,
  66     const std::string& device_path,
  67     const base::Callback<void(const std::string&, bool)>& callback) {
  68   const std::string& webcam_id = GetWebcamId(extension_id, device_path);
  69   WebcamResource* webcam_resource = FindWebcamResource(extension_id, webcam_id);
  70   if (webcam_resource)
  71     return false;
  72
  73   ViscaWebcam* visca_webcam(new ViscaWebcam(device_path, extension_id));
  74   visca_webcam->Open(base::Bind(
  75       &WebcamPrivateAPI::OnOpenSerialWebcam, weak_ptr_factory_.GetWeakPtr(),
  76       extension_id, device_path, make_scoped_refptr(visca_webcam), callback));
  77   return true;
  78 }
  79
  80 bool WebcamPrivateAPI::CloseWebcam(const std::string& extension_id,
  81                                    const std::string& webcam_id) {
  82   if (FindWebcamResource(extension_id, webcam_id)) {
  83     RemoveWebcamResource(extension_id, webcam_id);
  84     return true;
  85   }
  86   return false;
  87 }
  88
  89 void WebcamPrivateAPI::OnOpenSerialWebcam(
  90     const std::string& extension_id,
  91     const std::string& device_path,
  92     scoped_refptr<Webcam> webcam,
  93     const base::Callback<void(const std::string&, bool)>& callback,
  94     bool success) {
  95   if (success) {
  96     const std::string& webcam_id = GetWebcamId(extension_id, device_path);
  97     webcam_resource_manager_->Add(
  98         new WebcamResource(extension_id, webcam.get(), webcam_id));
  99     callback.Run(webcam_id, true);
 100   } else {
 101     callback.Run("", false);
 102   }
 103 }
 104
 105 bool WebcamPrivateAPI::GetDeviceId(const std::string& extension_id,
 106                                    const std::string& webcam_id,
 107                                    std::string* device_id) {
 108   GURL security_origin =
 109       extensions::Extension::GetBaseURLFromExtensionId(extension_id);
 110
 111   return content::GetMediaDeviceIDForHMAC(
 112       content::MEDIA_DEVICE_VIDEO_CAPTURE,
 113       browser_context_->GetResourceContext()->GetMediaDeviceIDSalt(),
 114       security_origin,
 115       webcam_id,
 116       device_id);
 117 }
 118
 119 std::string WebcamPrivateAPI::GetWebcamId(const std::string& extension_id,
 120                                           const std::string& device_id) {
 121   GURL security_origin =
 122       extensions::Extension::GetBaseURLFromExtensionId(extension_id);
 123
 124   return content::GetHMACForMediaDeviceID(
 125       browser_context_->GetResourceContext()->GetMediaDeviceIDSalt(),
 126       security_origin, device_id);
 127 }
 128
 129 WebcamResource* WebcamPrivateAPI::FindWebcamResource(
 130     const std::string& extension_id,
 131     const std::string& webcam_id) const {
 132   DCHECK(webcam_resource_manager_);
 133
 134   base::hash_set<int>* connection_ids =
 135       webcam_resource_manager_->GetResourceIds(extension_id);
 136   if (!connection_ids)
 137     return nullptr;
 138
 139   for (const auto& connection_id : *connection_ids) {
 140     WebcamResource* webcam_resource =
 141         webcam_resource_manager_->Get(extension_id, connection_id);
 142     if (webcam_resource && webcam_resource->GetWebcamId() == webcam_id)
 143       return webcam_resource;
 144   }
 145
 146   return nullptr;
 147 }
 148
 149 bool WebcamPrivateAPI::RemoveWebcamResource(const std::string& extension_id,
 150                                             const std::string& webcam_id) {
 151   DCHECK(webcam_resource_manager_);
 152
 153   base::hash_set<int>* connection_ids =
 154       webcam_resource_manager_->GetResourceIds(extension_id);
 155   if (!connection_ids)
 156     return false;
 157
 158   for (const auto& connection_id : *connection_ids) {
 159     WebcamResource* webcam_resource =
 160         webcam_resource_manager_->Get(extension_id, connection_id);
 161     if (webcam_resource && webcam_resource->GetWebcamId() == webcam_id) {
 162       webcam_resource_manager_->Remove(extension_id, connection_id);
 163       return true;
 164     }
 165   }
 166
 167   return false;
 168 }
 169
 170 WebcamPrivateOpenSerialWebcamFunction::WebcamPrivateOpenSerialWebcamFunction() {
 171 }
 172
 173 WebcamPrivateOpenSerialWebcamFunction::
 174     ~WebcamPrivateOpenSerialWebcamFunction() {
 175 }
 176
 177 bool WebcamPrivateOpenSerialWebcamFunction::RunAsync() {
 178   scoped_ptr<webcam_private::OpenSerialWebcam::Params> params(
 179       webcam_private::OpenSerialWebcam::Params::Create(*args_));
 180   EXTENSION_FUNCTION_VALIDATE(params.get());
 181
 182   if (WebcamPrivateAPI::Get(browser_context())
 183           ->OpenSerialWebcam(
 184               extension_id(), params->path,
 185               base::Bind(&WebcamPrivateOpenSerialWebcamFunction::OnOpenWebcam,
 186                          this))) {
 187     return true;
 188   } else {
 189     SetError(kPathInUse);
 190     return false;
 191   }
 192 }
 193
 194 void WebcamPrivateOpenSerialWebcamFunction::OnOpenWebcam(
 195     const std::string& webcam_id,
 196     bool success) {
 197   if (success) {
 198     SetResult(new base::StringValue(webcam_id));
 199     SendResponse(true);
 200   } else {
 201     SetError(kUnknownWebcam);
 202     SendResponse(false);
 203   }
 204 }
 205
 206 WebcamPrivateCloseWebcamFunction::WebcamPrivateCloseWebcamFunction() {
 207 }
 208
 209 WebcamPrivateCloseWebcamFunction::~WebcamPrivateCloseWebcamFunction() {
 210 }
 211
 212 bool WebcamPrivateCloseWebcamFunction::RunAsync() {
 213   scoped_ptr<webcam_private::CloseWebcam::Params> params(
 214       webcam_private::CloseWebcam::Params::Create(*args_));
 215   EXTENSION_FUNCTION_VALIDATE(params.get());
 216
 217   return WebcamPrivateAPI::Get(browser_context())
 218       ->CloseWebcam(extension_id(), params->webcam_id);
 219 }
 220
 221 WebcamPrivateSetFunction::WebcamPrivateSetFunction() {
 222 }
 223
 224 WebcamPrivateSetFunction::~WebcamPrivateSetFunction() {
 225 }
 226
 227 bool WebcamPrivateSetFunction::RunSync() {
 228   scoped_ptr<webcam_private::Set::Params> params(
 229       webcam_private::Set::Params::Create(*args_));
 230   EXTENSION_FUNCTION_VALIDATE(params.get());
 231
 232   Webcam* webcam = WebcamPrivateAPI::Get(browser_context())
 233                        ->GetWebcam(extension_id(), params->webcam_id);
 234   if (!webcam) {
 235     SetError(kUnknownWebcam);
 236     return false;
 237   }
 238
 239   if (params->config.pan) {
 240     webcam->SetPan(*(params->config.pan));
 241   }
 242
 243   if (params->config.pan_direction) {
 244     Webcam::PanDirection direction = Webcam::PAN_STOP;
 245     switch (params->config.pan_direction) {
 246       case webcam_private::PAN_DIRECTION_NONE:
 247       case webcam_private::PAN_DIRECTION_STOP:
 248         direction = Webcam::PAN_STOP;
 249         break;
 250
 251       case webcam_private::PAN_DIRECTION_RIGHT:
 252         direction = Webcam::PAN_RIGHT;
 253         break;
 254
 255       case webcam_private::PAN_DIRECTION_LEFT:
 256         direction = Webcam::PAN_LEFT;
 257         break;
 258     }
 259     webcam->SetPanDirection(direction);
 260   }
 261
 262   if (params->config.tilt) {
 263     webcam->SetTilt(*(params->config.tilt));
 264   }
 265
 266   if (params->config.tilt_direction) {
 267     Webcam::TiltDirection direction = Webcam::TILT_STOP;
 268     switch (params->config.tilt_direction) {
 269       case webcam_private::TILT_DIRECTION_NONE:
 270       case webcam_private::TILT_DIRECTION_STOP:
 271         direction = Webcam::TILT_STOP;
 272         break;
 273
 274       case webcam_private::TILT_DIRECTION_UP:
 275         direction = Webcam::TILT_UP;
 276         break;
 277
 278       case webcam_private::TILT_DIRECTION_DOWN:
 279         direction = Webcam::TILT_DOWN;
 280         break;
 281     }
 282     webcam->SetTiltDirection(direction);
 283   }
 284
 285   if (params->config.zoom) {
 286     webcam->SetZoom(*(params->config.zoom));
 287   }
 288
 289
 290   return true;
 291 }
 292
 293 WebcamPrivateGetFunction::WebcamPrivateGetFunction() {
 294 }
 295
 296 WebcamPrivateGetFunction::~WebcamPrivateGetFunction() {
 297 }
 298
 299 bool WebcamPrivateGetFunction::RunSync() {
 300   scoped_ptr<webcam_private::Get::Params> params(
 301       webcam_private::Get::Params::Create(*args_));
 302   EXTENSION_FUNCTION_VALIDATE(params.get());
 303
 304   Webcam* webcam = WebcamPrivateAPI::Get(browser_context())
 305                        ->GetWebcam(extension_id(), params->webcam_id);
 306   if (!webcam) {
 307     SetError(kUnknownWebcam);
 308     return false;
 309   }
 310
 311   webcam_private::WebcamConfiguration result;
 312
 313   int pan;
 314   if (webcam->GetPan(&pan))
 315     result.pan.reset(new double(pan));
 316
 317   int tilt;
 318   if (webcam->GetTilt(&tilt))
 319     result.tilt.reset(new double(tilt));
 320
 321   int zoom;
 322   if (webcam->GetZoom(&zoom))
 323     result.zoom.reset(new double(zoom));
 324
 325   SetResult(result.ToValue().release());
 326
 327   return true;
 328 }
 329
 330 WebcamPrivateResetFunction::WebcamPrivateResetFunction() {
 331 }
 332
 333 WebcamPrivateResetFunction::~WebcamPrivateResetFunction() {
 334 }
 335
 336 bool WebcamPrivateResetFunction::RunSync() {
 337   scoped_ptr<webcam_private::Reset::Params> params(
 338       webcam_private::Reset::Params::Create(*args_));
 339   EXTENSION_FUNCTION_VALIDATE(params.get());
 340
 341   Webcam* webcam = WebcamPrivateAPI::Get(browser_context())
 342                        ->GetWebcam(extension_id(), params->webcam_id);
 343   if (!webcam) {
 344     SetError(kUnknownWebcam);
 345     return false;
 346   }
 347
 348   webcam->Reset(params->config.pan, params->config.tilt, params->config.zoom);
 349
 350   return true;
 351 }
 352
 353 static base::LazyInstance<BrowserContextKeyedAPIFactory<WebcamPrivateAPI>>
 354     g_factory = LAZY_INSTANCE_INITIALIZER;
 355
 356 // static
 357 BrowserContextKeyedAPIFactory<WebcamPrivateAPI>*
 358 WebcamPrivateAPI::GetFactoryInstance() {
 359   return g_factory.Pointer();
 360 }
 361
 362 template <>
 363 void BrowserContextKeyedAPIFactory<WebcamPrivateAPI>
 364     ::DeclareFactoryDependencies() {
 365   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
 366   DependsOn(ProcessManagerFactory::GetInstance());
 367 }
 368
 369 }  // namespace extensions