// Copyright 2014 The Chromium Authors
// 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_private_api.h"
#include <memory>
#include "base/functional/bind.h"
#include "base/lazy_instance.h"
#include "components/media_device_salt/media_device_salt_service.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/media_device_id.h"
#include "content/public/browser/resource_context.h"
#include "extensions/browser/api/serial/serial_port_manager.h"
#include "extensions/browser/api/webcam_private/ip_webcam.h"
#include "extensions/browser/api/webcam_private/v4l2_webcam.h"
#include "extensions/browser/api/webcam_private/visca_webcam.h"
#include "extensions/browser/extensions_browser_client.h"
#include "extensions/browser/process_manager.h"
#include "extensions/browser/process_manager_factory.h"
#include "extensions/common/extension_id.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "url/origin.h"
namespace webcam_private = extensions::api::webcam_private;
namespace content {
class BrowserContext;
} // namespace content
namespace {
const char kPathInUse[] = "Path in use";
const char kUnknownWebcam[] = "Unknown webcam id";
const char kOpenSerialWebcamError[] = "Can't open serial webcam.";
const char kGetWebcamPTZError[] = "Can't get web camera pan/tilt/zoom.";
const char kSetWebcamPTZError[] = "Can't set web camera pan/tilt/zoom.";
const char kResetWebcamError[] = "Can't reset web camera.";
const char kSetHomeWebcamError[] = "Can't set home position";
const char kRestorePresetWebcamError[] = "Can't restore preset.";
const char kSetPresetWebcamError[] = "Can't set preset.";
} // namespace
namespace extensions {
// static
WebcamPrivateAPI* WebcamPrivateAPI::Get(content::BrowserContext* context) {
return GetFactoryInstance()->Get(context);
}
WebcamPrivateAPI::WebcamPrivateAPI(content::BrowserContext* context)
: browser_context_(context) {
webcam_resource_manager_ =
std::make_unique<ApiResourceManager<WebcamResource>>(context);
}
WebcamPrivateAPI::~WebcamPrivateAPI() {
}
void WebcamPrivateAPI::OnGotDeviceIdOnUIThread(
const ExtensionId& extension_id,
const std::string& webcam_id,
base::OnceCallback<void(Webcam*)> callback,
const std::optional<std::string>& device_id) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (!device_id) {
std::move(callback).Run(nullptr);
return;
}
Webcam* webcam = nullptr;
if (device_id->compare(0, 8, "192.168.") == 0) {
webcam = new IpWebcam(device_id.value());
} else {
V4L2Webcam* v4l2_webcam = new V4L2Webcam(device_id.value());
if (!v4l2_webcam->Open()) {
std::move(callback).Run(nullptr);
return;
}
webcam = v4l2_webcam;
}
webcam_resource_manager_->Add(
new WebcamResource(extension_id, webcam, webcam_id));
std::move(callback).Run(webcam);
}
// static
void WebcamPrivateAPI::GetDeviceIdOnIOThread(
std::string salt,
url::Origin security_origin,
std::string hmac_device_id,
base::OnceCallback<void(const std::optional<std::string>&)> callback) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
content::GetMediaDeviceIDForHMAC(
blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE, salt,
std::move(security_origin), std::move(hmac_device_id),
content::GetUIThreadTaskRunner({}), std::move(callback));
}
void WebcamPrivateAPI::GetWebcam(const ExtensionId& extension_id,
const std::string& webcam_id,
base::OnceCallback<void(Webcam*)> callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
WebcamResource* webcam_resource = FindWebcamResource(extension_id, webcam_id);
if (webcam_resource) {
Webcam* webcam = webcam_resource->GetWebcam();
std::move(callback).Run(webcam);
return;
}
url::Origin security_origin =
extensions::Extension::CreateOriginFromExtensionId(extension_id);
if (media_device_salt::MediaDeviceSaltService* salt_service =
ExtensionsBrowserClient::Get()->GetMediaDeviceSaltService(
browser_context_)) {
salt_service->GetSalt(
blink::StorageKey::CreateFirstParty(security_origin),
base::BindOnce(&WebcamPrivateAPI::GetDeviceIdOnUIThread,
weak_ptr_factory_.GetWeakPtr(), security_origin,
extension_id, webcam_id, std::move(callback)));
} else {
// If the embedder does not provide a salt service, use the browser
// context's unique ID as salt.
GetDeviceIdOnUIThread(security_origin, extension_id, webcam_id,
std::move(callback), browser_context_->UniqueId());
}
}
void WebcamPrivateAPI::GetDeviceIdOnUIThread(
const url::Origin& security_origin,
const ExtensionId& extension_id,
const std::string& webcam_id,
base::OnceCallback<void(Webcam*)> webcam_callback,
const std::string& salt) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
auto got_device_cb =
base::BindOnce(&WebcamPrivateAPI::OnGotDeviceIdOnUIThread,
weak_ptr_factory_.GetWeakPtr(), extension_id, webcam_id,
std::move(webcam_callback));
content::GetIOThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&WebcamPrivateAPI::GetDeviceIdOnIOThread, salt,
security_origin, webcam_id, std::move(got_device_cb)));
}
void WebcamPrivateAPI::OpenSerialWebcam(
const ExtensionId& extension_id,
const std::string& device_path,
const base::RepeatingCallback<void(const std::string&,
OpenSerialWebcamResult)>& callback) {
GetWebcamId(extension_id, device_path,
base::BindOnce(&WebcamPrivateAPI::GotWebcamId,
weak_ptr_factory_.GetWeakPtr(), extension_id,
device_path, callback));
}
void WebcamPrivateAPI::GotWebcamId(
const ExtensionId& extension_id,
const std::string& device_path,
const base::RepeatingCallback<void(const std::string&,
OpenSerialWebcamResult)>& callback,
const std::string& webcam_id) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
WebcamResource* webcam_resource = FindWebcamResource(extension_id, webcam_id);
if (webcam_resource) {
callback.Run("", OpenSerialWebcamResult::kInUse);
return;
}
mojo::PendingRemote<device::mojom::SerialPort> port;
auto* port_manager = api::SerialPortManager::Get(browser_context_);
DCHECK(port_manager);
auto visca_webcam = base::MakeRefCounted<ViscaWebcam>();
visca_webcam->Open(
extension_id, port_manager, device_path,
base::BindRepeating(&WebcamPrivateAPI::OnOpenSerialWebcam,
weak_ptr_factory_.GetWeakPtr(), webcam_id,
extension_id, device_path, visca_webcam, callback));
}
bool WebcamPrivateAPI::CloseWebcam(const ExtensionId& extension_id,
const std::string& webcam_id) {
if (FindWebcamResource(extension_id, webcam_id)) {
RemoveWebcamResource(extension_id, webcam_id);
return true;
}
return false;
}
void WebcamPrivateAPI::OnOpenSerialWebcam(
const std::string& webcam_id,
const ExtensionId& extension_id,
const std::string& device_path,
scoped_refptr<Webcam> webcam,
const base::RepeatingCallback<void(const std::string&,
OpenSerialWebcamResult)>& callback,
bool success) {
if (success) {
webcam_resource_manager_->Add(
new WebcamResource(extension_id, webcam.get(), webcam_id));
callback.Run(webcam_id, OpenSerialWebcamResult::kSuccess);
} else {
callback.Run("", OpenSerialWebcamResult::kError);
}
}
void WebcamPrivateAPI::GetWebcamId(
const ExtensionId& extension_id,
const std::string& device_id,
base::OnceCallback<void(const std::string&)> webcam_id_callback) {
url::Origin security_origin =
extensions::Extension::CreateOriginFromExtensionId(extension_id);
if (media_device_salt::MediaDeviceSaltService* salt_service =
ExtensionsBrowserClient::Get()->GetMediaDeviceSaltService(
browser_context_)) {
salt_service->GetSalt(
blink::StorageKey::CreateFirstParty(security_origin),
base::BindOnce(&WebcamPrivateAPI::FinalizeGetWebcamId,
weak_ptr_factory_.GetWeakPtr(), security_origin,
device_id, std::move(webcam_id_callback)));
} else {
// If the embedder does not provide a salt service, use the browser
// context's unique ID as salt.
FinalizeGetWebcamId(security_origin, device_id,
std::move(webcam_id_callback),
browser_context_->UniqueId());
}
}
void WebcamPrivateAPI::FinalizeGetWebcamId(
const url::Origin& security_origin,
const std::string& device_id,
base::OnceCallback<void(const std::string&)> webcam_id_callback,
const std::string& device_id_salt) {
std::string webcam_id = content::GetHMACForMediaDeviceID(
device_id_salt, security_origin, device_id);
std::move(webcam_id_callback).Run(webcam_id);
}
WebcamResource* WebcamPrivateAPI::FindWebcamResource(
const ExtensionId& extension_id,
const std::string& webcam_id) const {
DCHECK(webcam_resource_manager_);
std::unordered_set<int>* connection_ids =
webcam_resource_manager_->GetResourceIds(extension_id);
if (!connection_ids)
return nullptr;
for (const auto& connection_id : *connection_ids) {
WebcamResource* webcam_resource =
webcam_resource_manager_->Get(extension_id, connection_id);
if (webcam_resource && webcam_resource->GetWebcamId() == webcam_id)
return webcam_resource;
}
return nullptr;
}
bool WebcamPrivateAPI::RemoveWebcamResource(const ExtensionId& extension_id,
const std::string& webcam_id) {
DCHECK(webcam_resource_manager_);
std::unordered_set<int>* connection_ids =
webcam_resource_manager_->GetResourceIds(extension_id);
if (!connection_ids)
return false;
for (const auto& connection_id : *connection_ids) {
WebcamResource* webcam_resource =
webcam_resource_manager_->Get(extension_id, connection_id);
if (webcam_resource && webcam_resource->GetWebcamId() == webcam_id) {
webcam_resource_manager_->Remove(extension_id, connection_id);
return true;
}
}
return false;
}
WebcamPrivateOpenSerialWebcamFunction::WebcamPrivateOpenSerialWebcamFunction() {
}
WebcamPrivateOpenSerialWebcamFunction::
~WebcamPrivateOpenSerialWebcamFunction() {
}
ExtensionFunction::ResponseAction WebcamPrivateOpenSerialWebcamFunction::Run() {
std::optional<webcam_private::OpenSerialWebcam::Params> params =
webcam_private::OpenSerialWebcam::Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
WebcamPrivateAPI::Get(browser_context())
->OpenSerialWebcam(
extension_id(), params->path,
base::BindRepeating(
&WebcamPrivateOpenSerialWebcamFunction::OnOpenWebcam, this));
// OpenSerialWebcam responds asynchronously.
return RespondLater();
}
void WebcamPrivateOpenSerialWebcamFunction::OnOpenWebcam(
const std::string& webcam_id,
WebcamPrivateAPI::OpenSerialWebcamResult result) {
if (result == WebcamPrivateAPI::OpenSerialWebcamResult::kSuccess) {
Respond(WithArguments(webcam_id));
} else if (result == WebcamPrivateAPI::OpenSerialWebcamResult::kError) {
Respond(Error(kOpenSerialWebcamError));
} else if (result == WebcamPrivateAPI::OpenSerialWebcamResult::kInUse) {
Respond(Error(kPathInUse));
}
}
WebcamPrivateCloseWebcamFunction::WebcamPrivateCloseWebcamFunction() {
}
WebcamPrivateCloseWebcamFunction::~WebcamPrivateCloseWebcamFunction() {
}
ExtensionFunction::ResponseAction WebcamPrivateCloseWebcamFunction::Run() {
std::optional<webcam_private::CloseWebcam::Params> params =
webcam_private::CloseWebcam::Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
const bool success = WebcamPrivateAPI::Get(browser_context())
->CloseWebcam(extension_id(), params->webcam_id);
return RespondNow(success ? NoArguments() : Error(kUnknownErrorDoNotUse));
}
WebcamPrivateSetFunction::WebcamPrivateSetFunction() {
}
WebcamPrivateSetFunction::~WebcamPrivateSetFunction() {
}
ExtensionFunction::ResponseAction WebcamPrivateSetFunction::Run() {
std::optional<webcam_private::Set::Params> params =
webcam_private::Set::Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
std::string webcam_id = params->webcam_id;
auto on_webcam = base::BindOnce(&WebcamPrivateSetFunction::OnWebcam, this,
std::move(params));
WebcamPrivateAPI::Get(browser_context())
->GetWebcam(extension_id(), webcam_id, std::move(on_webcam));
return did_respond() ? AlreadyResponded() : RespondLater();
}
void WebcamPrivateSetFunction::OnWebcam(
std::optional<webcam_private::Set::Params> params,
Webcam* webcam) {
if (!webcam)
return Respond(Error(kUnknownWebcam));
int pan_speed = 0;
int tilt_speed = 0;
if (params->config.pan_speed)
pan_speed = *(params->config.pan_speed);
if (params->config.tilt_speed)
tilt_speed = *(params->config.tilt_speed);
// Count all of the requests we will send before potentially sending any.
pending_num_set_webcam_param_requests_ = 0;
if (params->config.pan) {
++pending_num_set_webcam_param_requests_;
}
if (params->config.pan_direction != webcam_private::PanDirection::kNone) {
++pending_num_set_webcam_param_requests_;
}
if (params->config.tilt) {
++pending_num_set_webcam_param_requests_;
}
if (params->config.tilt_direction != webcam_private::TiltDirection::kNone) {
++pending_num_set_webcam_param_requests_;
}
if (params->config.zoom) {
++pending_num_set_webcam_param_requests_;
}
if (params->config.autofocus_state != webcam_private::AutofocusState::kNone) {
++pending_num_set_webcam_param_requests_;
}
if (params->config.focus) {
++pending_num_set_webcam_param_requests_;
}
if (params->config.pan) {
webcam->SetPan(*(params->config.pan), pan_speed,
base::BindRepeating(
&WebcamPrivateSetFunction::OnSetWebcamParameters, this));
}
if (params->config.pan_direction != webcam_private::PanDirection::kNone) {
Webcam::PanDirection direction = Webcam::PAN_STOP;
switch (params->config.pan_direction) {
case webcam_private::PanDirection::kNone:
case webcam_private::PanDirection::kStop:
direction = Webcam::PAN_STOP;
break;
case webcam_private::PanDirection::kRight:
direction = Webcam::PAN_RIGHT;
break;
case webcam_private::PanDirection::kLeft:
direction = Webcam::PAN_LEFT;
break;
}
webcam->SetPanDirection(
direction, pan_speed,
base::BindRepeating(&WebcamPrivateSetFunction::OnSetWebcamParameters,
this));
}
if (params->config.tilt) {
webcam->SetTilt(
*(params->config.tilt), tilt_speed,
base::BindRepeating(&WebcamPrivateSetFunction::OnSetWebcamParameters,
this));
}
if (params->config.tilt_direction != webcam_private::TiltDirection::kNone) {
Webcam::TiltDirection direction = Webcam::TILT_STOP;
switch (params->config.tilt_direction) {
case webcam_private::TiltDirection::kNone:
case webcam_private::TiltDirection::kStop:
direction = Webcam::TILT_STOP;
break;
case webcam_private::TiltDirection::kUp:
direction = Webcam::TILT_UP;
break;
case webcam_private::TiltDirection::kDown:
direction = Webcam::TILT_DOWN;
break;
}
webcam->SetTiltDirection(
direction, tilt_speed,
base::BindRepeating(&WebcamPrivateSetFunction::OnSetWebcamParameters,
this));
}
if (params->config.zoom) {
webcam->SetZoom(
*(params->config.zoom),
base::BindRepeating(&WebcamPrivateSetFunction::OnSetWebcamParameters,
this));
}
if (params->config.autofocus_state != webcam_private::AutofocusState::kNone) {
Webcam::AutofocusState state = Webcam::AUTOFOCUS_ON;
switch (params->config.autofocus_state) {
case webcam_private::AutofocusState::kNone:
case webcam_private::AutofocusState::kOff:
state = Webcam::AUTOFOCUS_OFF;
break;
case webcam_private::AutofocusState::kOn:
state = Webcam::AUTOFOCUS_ON;
break;
}
webcam->SetAutofocusState(
state, base::BindRepeating(
&WebcamPrivateSetFunction::OnSetWebcamParameters, this));
}
if (params->config.focus) {
webcam->SetFocus(
*(params->config.focus),
base::BindRepeating(&WebcamPrivateSetFunction::OnSetWebcamParameters,
this));
}
}
void WebcamPrivateSetFunction::OnSetWebcamParameters(bool success) {
failed_ |= !success;
--pending_num_set_webcam_param_requests_;
DCHECK_GE(pending_num_set_webcam_param_requests_, 0);
if (pending_num_set_webcam_param_requests_ != 0) {
return;
}
if (failed_) {
Respond(Error(kSetWebcamPTZError));
return;
}
// Reply with a dummy, empty configuration.
webcam_private::WebcamCurrentConfiguration result;
Respond(WithArguments(result.ToValue()));
}
WebcamPrivateGetFunction::WebcamPrivateGetFunction()
: min_pan_(0),
max_pan_(0),
pan_(0),
min_tilt_(0),
max_tilt_(0),
tilt_(0),
min_zoom_(0),
max_zoom_(0),
zoom_(0),
min_focus_(0),
max_focus_(0),
focus_(0),
got_pan_(false),
got_tilt_(false),
got_zoom_(false),
got_focus_(false),
success_(false) {}
WebcamPrivateGetFunction::~WebcamPrivateGetFunction() {
}
ExtensionFunction::ResponseAction WebcamPrivateGetFunction::Run() {
std::optional<webcam_private::Get::Params> params =
webcam_private::Get::Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
auto on_webcam = base::BindOnce(&WebcamPrivateGetFunction::OnWebcam, this);
WebcamPrivateAPI::Get(browser_context())
->GetWebcam(extension_id(), params->webcam_id, std::move(on_webcam));
// Might have already responded if webcam_resource_manager_ already has the
// Webcam.
return did_respond() ? AlreadyResponded() : RespondLater();
}
void WebcamPrivateGetFunction::OnWebcam(Webcam* webcam) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (!webcam) {
Respond(Error(kUnknownWebcam));
return;
}
webcam->GetPan(base::BindRepeating(
&WebcamPrivateGetFunction::OnGetWebcamParameters, this, INQUIRY_PAN));
webcam->GetTilt(base::BindRepeating(
&WebcamPrivateGetFunction::OnGetWebcamParameters, this, INQUIRY_TILT));
webcam->GetZoom(base::BindRepeating(
&WebcamPrivateGetFunction::OnGetWebcamParameters, this, INQUIRY_ZOOM));
webcam->GetFocus(base::BindRepeating(
&WebcamPrivateGetFunction::OnGetWebcamParameters, this, INQUIRY_FOCUS));
}
// Retrieve webcam parameters. Will respond a config holding the requested
// values if any of the requests succeeds. Otherwise will respond an error.
void WebcamPrivateGetFunction::OnGetWebcamParameters(InquiryType type,
bool success,
int value,
int min_value,
int max_value) {
success_ = success_ || success;
switch (type) {
case INQUIRY_PAN:
if (success) {
min_pan_ = min_value;
max_pan_ = max_value;
pan_ = value;
}
got_pan_ = true;
break;
case INQUIRY_TILT:
if (success) {
min_tilt_ = min_value;
max_tilt_ = max_value;
tilt_ = value;
}
got_tilt_ = true;
break;
case INQUIRY_ZOOM:
if (success) {
min_zoom_ = min_value;
max_zoom_ = max_value;
zoom_ = value;
}
got_zoom_ = true;
break;
case INQUIRY_FOCUS:
if (success) {
min_focus_ = min_value;
max_focus_ = max_value;
focus_ = value;
}
got_focus_ = true;
break;
}
if (got_pan_ && got_tilt_ && got_zoom_ && got_focus_) {
if (!success_) {
Respond(Error(kGetWebcamPTZError));
return;
}
webcam_private::WebcamCurrentConfiguration result;
if (min_pan_ != max_pan_) {
result.pan_range.emplace();
result.pan_range->min = min_pan_;
result.pan_range->max = max_pan_;
}
if (min_tilt_ != max_tilt_) {
result.tilt_range.emplace();
result.tilt_range->min = min_tilt_;
result.tilt_range->max = max_tilt_;
}
if (min_zoom_ != max_zoom_) {
result.zoom_range.emplace();
result.zoom_range->min = min_zoom_;
result.zoom_range->max = max_zoom_;
}
if (min_focus_ != max_focus_) {
result.focus_range.emplace();
result.focus_range->min = min_focus_;
result.focus_range->max = max_focus_;
}
result.pan = pan_;
result.tilt = tilt_;
result.zoom = zoom_;
result.focus = focus_;
Respond(WithArguments(result.ToValue()));
}
}
WebcamPrivateResetFunction::WebcamPrivateResetFunction() {
}
WebcamPrivateResetFunction::~WebcamPrivateResetFunction() {
}
ExtensionFunction::ResponseAction WebcamPrivateResetFunction::Run() {
std::optional<webcam_private::Reset::Params> params =
webcam_private::Reset::Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
std::string webcam_id = params->webcam_id;
auto on_webcam = base::BindOnce(&WebcamPrivateResetFunction::OnWebcam, this,
std::move(params));
WebcamPrivateAPI::Get(browser_context())
->GetWebcam(extension_id(), webcam_id, std::move(on_webcam));
// Might have already responsed if webcam_resource_manager_ already has the
// Webcam and WebCam::Reset just runs the callback.
return did_respond() ? AlreadyResponded() : RespondLater();
}
void WebcamPrivateResetFunction::OnWebcam(
std::optional<webcam_private::Reset::Params> params,
Webcam* webcam) {
if (!webcam)
return Respond(Error(kUnknownWebcam));
webcam->Reset(
params->config.pan.has_value(), params->config.tilt.has_value(),
params->config.zoom.has_value(),
base::BindRepeating(&WebcamPrivateResetFunction::OnResetWebcam, this));
}
void WebcamPrivateResetFunction::OnResetWebcam(bool success) {
if (!success) {
Respond(Error(kResetWebcamError));
return;
}
// Reply with a dummy, empty configuration.
webcam_private::WebcamCurrentConfiguration result;
Respond(WithArguments(result.ToValue()));
}
WebcamPrivateSetHomeFunction::WebcamPrivateSetHomeFunction() = default;
WebcamPrivateSetHomeFunction::~WebcamPrivateSetHomeFunction() = default;
ExtensionFunction::ResponseAction WebcamPrivateSetHomeFunction::Run() {
std::optional<webcam_private::SetHome::Params> params =
webcam_private::SetHome::Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
auto on_webcam =
base::BindOnce(&WebcamPrivateSetHomeFunction::OnWebcam, this);
WebcamPrivateAPI::Get(browser_context())
->GetWebcam(extension_id(), params->webcam_id, std::move(on_webcam));
return did_respond() ? AlreadyResponded() : RespondLater();
}
void WebcamPrivateSetHomeFunction::OnWebcam(Webcam* webcam) {
if (!webcam)
return Respond(Error(kUnknownWebcam));
webcam->SetHome(base::BindRepeating(
&WebcamPrivateSetHomeFunction::OnSetHomeWebcam, this));
}
void WebcamPrivateSetHomeFunction::OnSetHomeWebcam(bool success) {
if (!success) {
Respond(Error(kSetHomeWebcamError));
return;
}
// Reply with a dummy, empty configuration.
webcam_private::WebcamCurrentConfiguration result;
Respond(WithArguments(result.ToValue()));
}
WebcamPrivateRestoreCameraPresetFunction::
WebcamPrivateRestoreCameraPresetFunction() {}
WebcamPrivateRestoreCameraPresetFunction::
~WebcamPrivateRestoreCameraPresetFunction() {}
ExtensionFunction::ResponseAction
WebcamPrivateRestoreCameraPresetFunction::Run() {
std::optional<webcam_private::RestoreCameraPreset::Params> params =
webcam_private::RestoreCameraPreset::Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
auto on_webcam =
base::BindOnce(&WebcamPrivateRestoreCameraPresetFunction::OnWebcam, this,
params->preset_number);
WebcamPrivateAPI::Get(browser_context())
->GetWebcam(extension_id(), params->webcam_id, std::move(on_webcam));
return did_respond() ? AlreadyResponded() : RespondLater();
}
void WebcamPrivateRestoreCameraPresetFunction::OnWebcam(int preset_number,
Webcam* webcam) {
if (!webcam) {
Respond(Error(kUnknownWebcam));
return;
}
webcam->RestoreCameraPreset(
preset_number,
base::BindRepeating(&WebcamPrivateRestoreCameraPresetFunction::
OnRestoreCameraPresetWebcam,
this));
}
void WebcamPrivateRestoreCameraPresetFunction::OnRestoreCameraPresetWebcam(
bool success) {
if (!success) {
Respond(Error(kRestorePresetWebcamError));
return;
}
// Reply with a dummy, empty configuration.
webcam_private::WebcamCurrentConfiguration result;
Respond(WithArguments(result.ToValue()));
}
WebcamPrivateSetCameraPresetFunction::WebcamPrivateSetCameraPresetFunction() =
default;
WebcamPrivateSetCameraPresetFunction::~WebcamPrivateSetCameraPresetFunction() =
default;
ExtensionFunction::ResponseAction WebcamPrivateSetCameraPresetFunction::Run() {
std::optional<webcam_private::SetCameraPreset::Params> params =
webcam_private::SetCameraPreset::Params::Create(args());
EXTENSION_FUNCTION_VALIDATE(params);
auto on_webcam =
base::BindOnce(&WebcamPrivateSetCameraPresetFunction::OnWebcam, this,
params->preset_number);
WebcamPrivateAPI::Get(browser_context())
->GetWebcam(extension_id(), params->webcam_id, std::move(on_webcam));
return did_respond() ? AlreadyResponded() : RespondLater();
}
void WebcamPrivateSetCameraPresetFunction::OnWebcam(int preset_number,
Webcam* webcam) {
if (!webcam) {
Respond(Error(kUnknownWebcam));
return;
}
webcam->SetCameraPreset(
preset_number,
base::BindRepeating(
&WebcamPrivateSetCameraPresetFunction::OnSetCameraPresetWebcam,
this));
}
void WebcamPrivateSetCameraPresetFunction::OnSetCameraPresetWebcam(
bool success) {
if (!success) {
Respond(Error(kSetPresetWebcamError));
return;
}
// Reply with a dummy, empty configuration.
webcam_private::WebcamCurrentConfiguration result;
Respond(WithArguments(result.ToValue()));
}
static base::LazyInstance<BrowserContextKeyedAPIFactory<WebcamPrivateAPI>>::
DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
// static
BrowserContextKeyedAPIFactory<WebcamPrivateAPI>*
WebcamPrivateAPI::GetFactoryInstance() {
return g_factory.Pointer();
}
template <>
void BrowserContextKeyedAPIFactory<WebcamPrivateAPI>
::DeclareFactoryDependencies() {
DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
DependsOn(ProcessManagerFactory::GetInstance());
}
} // namespace extensions
Codebase Browser
chromium