Skip to content

GitLab

T
tangled
Commit 747c4ef9 authored by rdevlin.cronin's avatar rdevlin.cronin Committed by Commit bot
Browse files
Options

[Extensions] Convert some SyncExtensionFunctions 

SyncExtensionFunctions, AsyncExtensionFunctions,
ChromeSyncExtensionFunctions, and ChromeAsyncExtensionFunctions are
deprecated.

Remove SyncExtensionFunctions from:
- tab_capture
- virtual_keyboard_private

BUG=634140

Review-Url: https://codereview.chromium.org/2272563011
Cr-Commit-Position: refs/heads/master@{#414832}
parent a0ff8862
Hide whitespace changes
Inline Side-by-side
Showing with 136 additions and 165 deletions
chrome/browser/extensions/api/tab_capture/tab_capture_api.cc
View file @ 747c4ef9
......@@ -274,7 +274,7 @@ bool TabCaptureGetCapturedTabsFunction::RunSync() {
return true;
}
bool TabCaptureCaptureOffscreenTabFunction::RunSync() {
ExtensionFunction::ResponseAction TabCaptureCaptureOffscreenTabFunction::Run() {
std::unique_ptr<TabCapture::CaptureOffscreenTab::Params> params =
TabCapture::CaptureOffscreenTab::Params::Create(*args_);
EXTENSION_FUNCTION_VALIDATE(params);
......@@ -291,21 +291,15 @@ bool TabCaptureCaptureOffscreenTabFunction::RunSync() {
arraysize(kChromecastExtensionIds)) ||
SimpleFeature::IsIdInArray(extension()->id(), kMediaRouterExtensionIds,
arraysize(kMediaRouterExtensionIds));
if (!is_whitelisted_extension) {
error_ = kNotWhitelistedForOffscreenTabApi;
return false;
}
if (!is_whitelisted_extension)
return RespondNow(Error(kNotWhitelistedForOffscreenTabApi));
const GURL start_url(params->start_url);
if (!IsAcceptableOffscreenTabUrl(start_url)) {
SetError(kInvalidStartUrl);
return false;
}
if (!IsAcceptableOffscreenTabUrl(start_url))
return RespondNow(Error(kInvalidStartUrl));
if (!OptionsSpecifyAudioOrVideo(params->options)) {
SetError(kNoAudioOrVideo);
return false;
}
if (!OptionsSpecifyAudioOrVideo(params->options))
return RespondNow(Error(kNoAudioOrVideo));
content::WebContents* const extension_web_contents = GetSenderWebContents();
EXTENSION_FUNCTION_VALIDATE(extension_web_contents);
......@@ -315,17 +309,14 @@ bool TabCaptureCaptureOffscreenTabFunction::RunSync() {
DetermineInitialSize(params->options),
(is_whitelisted_extension && params->options.presentation_id) ?
*params->options.presentation_id : std::string());
if (!offscreen_tab) {
SetError(kTooManyOffscreenTabs);
return false;
}
if (!offscreen_tab)
return RespondNow(Error(kTooManyOffscreenTabs));
if (!TabCaptureRegistry::Get(browser_context())->AddRequest(
offscreen_tab->web_contents(), extension()->id(), true)) {
// TODO(miu): Allow multiple consumers of single tab capture.
// http://crbug.com/535336
SetError(kCapturingSameOffscreenTab);
return false;
return RespondNow(Error(kCapturingSameOffscreenTab));
}
FilterDeprecatedGoogConstraints(&params->options);
AddMediaStreamSourceConstraints(offscreen_tab->web_contents(),
......@@ -335,10 +326,7 @@ bool TabCaptureCaptureOffscreenTabFunction::RunSync() {
// the custom JS bindings in the extension's render process to complete the
// request. See the comment at end of TabCaptureCaptureFunction::RunSync()
// for more details.
std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
result->MergeDictionary(params->options.ToValue().get());
SetResult(std::move(result));
return true;
return RespondNow(OneArgument(params->options.ToValue()));
}
// static
......
chrome/browser/extensions/api/tab_capture/tab_capture_api.h
View file @ 747c4ef9
......@@ -45,7 +45,7 @@ class TabCaptureGetCapturedTabsFunction : public ChromeSyncExtensionFunction {
bool RunSync() final;
};
class TabCaptureCaptureOffscreenTabFunction : public SyncExtensionFunction {
class TabCaptureCaptureOffscreenTabFunction : public UIThreadExtensionFunction {
public:
DECLARE_EXTENSION_FUNCTION("tabCapture.captureOffscreenTab",
TABCAPTURE_CAPTUREOFFSCREENTAB)
......@@ -59,7 +59,7 @@ class TabCaptureCaptureOffscreenTabFunction : public SyncExtensionFunction {
~TabCaptureCaptureOffscreenTabFunction() final {}
// ExtensionFunction:
bool RunSync() final;
ResponseAction Run() final;
};
} // namespace extensions
......
extensions/browser/api/virtual_keyboard_private/virtual_keyboard_private_api.cc
View file @ 747c4ef9
......@@ -15,10 +15,6 @@
#include "extensions/common/api/virtual_keyboard_private.h"
#include "ui/events/event.h"
namespace SetMode = extensions::api::virtual_keyboard_private::SetMode;
namespace SetRequestedKeyboardState =
extensions::api::virtual_keyboard_private::SetKeyboardState;
namespace extensions {
namespace {
......@@ -27,151 +23,122 @@ const char kNotYetImplementedError[] =
"API is not implemented on this platform.";
const char kVirtualKeyboardNotEnabled[] =
"The virtual keyboard is not enabled.";
const char kUnknownError[] = "Unknown error.";
namespace keyboard = api::virtual_keyboard_private;
} // namespace
typedef BrowserContextKeyedAPIFactory<VirtualKeyboardAPI> factory;
bool VirtualKeyboardPrivateFunction::PreRunValidation(std::string* error) {
if (!UIThreadExtensionFunction::PreRunValidation(error))
return false;
VirtualKeyboardDelegate* GetDelegate(SyncExtensionFunction* f) {
VirtualKeyboardAPI* api = factory::Get(f->browser_context());
VirtualKeyboardAPI* api =
BrowserContextKeyedAPIFactory<VirtualKeyboardAPI>::Get(browser_context());
DCHECK(api);
return api ? api->delegate() : nullptr;
delegate_ = api->delegate();
if (!delegate_) {
*error = kNotYetImplementedError;
return false;
}
return true;
}
} // namespace
VirtualKeyboardPrivateFunction::~VirtualKeyboardPrivateFunction() {}
bool VirtualKeyboardPrivateInsertTextFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate) {
base::string16 text;
EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &text));
return delegate->InsertText(text);
}
error_ = kNotYetImplementedError;
return false;
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateInsertTextFunction::Run() {
base::string16 text;
EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &text));
if (!delegate()->InsertText(text))
return RespondNow(Error(kUnknownError));
return RespondNow(NoArguments());
}
bool VirtualKeyboardPrivateSendKeyEventFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate) {
base::Value* options_value = nullptr;
base::DictionaryValue* params = nullptr;
std::string type;
int char_value;
int key_code;
std::string key_name;
int modifiers;
EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &options_value));
EXTENSION_FUNCTION_VALIDATE(options_value->GetAsDictionary(&params));
EXTENSION_FUNCTION_VALIDATE(params->GetString("type", &type));
EXTENSION_FUNCTION_VALIDATE(params->GetInteger("charValue", &char_value));
EXTENSION_FUNCTION_VALIDATE(params->GetInteger("keyCode", &key_code));
EXTENSION_FUNCTION_VALIDATE(params->GetString("keyName", &key_name));
EXTENSION_FUNCTION_VALIDATE(params->GetInteger("modifiers", &modifiers));
return delegate->SendKeyEvent(
type, char_value, key_code, key_name, modifiers);
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateSendKeyEventFunction::Run() {
std::unique_ptr<keyboard::SendKeyEvent::Params> params(
keyboard::SendKeyEvent::Params::Create(*args_));
EXTENSION_FUNCTION_VALIDATE(params);
EXTENSION_FUNCTION_VALIDATE(params->key_event.modifiers);
const keyboard::VirtualKeyboardEvent& event = params->key_event;
if (!delegate()->SendKeyEvent(keyboard::ToString(event.type),
event.char_value, event.key_code,
event.key_name, *event.modifiers)) {
return RespondNow(Error(kUnknownError));
}
error_ = kNotYetImplementedError;
return false;
return RespondNow(NoArguments());
}
bool VirtualKeyboardPrivateHideKeyboardFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate)
return delegate->HideKeyboard();
error_ = kNotYetImplementedError;
return false;
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateHideKeyboardFunction::Run() {
if (!delegate()->HideKeyboard())
return RespondNow(Error(kUnknownError));
return RespondNow(NoArguments());
}
bool VirtualKeyboardPrivateSetHotrodKeyboardFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate) {
bool enable;
EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(0, &enable));
delegate->SetHotrodKeyboard(enable);
return true;
}
error_ = kNotYetImplementedError;
return false;
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateSetHotrodKeyboardFunction::Run() {
bool enable = false;
EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(0, &enable));
delegate()->SetHotrodKeyboard(enable);
return RespondNow(NoArguments());
}
bool VirtualKeyboardPrivateLockKeyboardFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate) {
bool lock;
EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(0, &lock));
return delegate->LockKeyboard(lock);
}
error_ = kNotYetImplementedError;
return false;
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateLockKeyboardFunction::Run() {
bool lock = false;
EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(0, &lock));
if (!delegate()->LockKeyboard(lock))
return RespondNow(Error(kUnknownError));
return RespondNow(NoArguments());
}
bool VirtualKeyboardPrivateKeyboardLoadedFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate)
return delegate->OnKeyboardLoaded();
error_ = kNotYetImplementedError;
return false;
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateKeyboardLoadedFunction::Run() {
if (!delegate()->OnKeyboardLoaded())
return RespondNow(Error(kUnknownError));
return RespondNow(NoArguments());
}
bool VirtualKeyboardPrivateGetKeyboardConfigFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate) {
std::unique_ptr<base::DictionaryValue> results(new base::DictionaryValue());
if (delegate->GetKeyboardConfig(results.get())) {
SetResult(std::move(results));
return true;
}
}
return false;
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateGetKeyboardConfigFunction::Run() {
std::unique_ptr<base::DictionaryValue> results(new base::DictionaryValue());
if (!delegate()->GetKeyboardConfig(results.get()))
return RespondNow(Error(kUnknownError));
return RespondNow(OneArgument(std::move(results)));
}
bool VirtualKeyboardPrivateOpenSettingsFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate) {
if (delegate->IsLanguageSettingsEnabled())
return delegate->ShowLanguageSettings();
return false;
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateOpenSettingsFunction::Run() {
if (!delegate()->IsLanguageSettingsEnabled() ||
!delegate()->ShowLanguageSettings()) {
return RespondNow(Error(kUnknownError));
}
error_ = kNotYetImplementedError;
return false;
return RespondNow(NoArguments());
}
bool VirtualKeyboardPrivateSetModeFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate) {
std::unique_ptr<SetMode::Params> params = SetMode::Params::Create(*args_);
EXTENSION_FUNCTION_VALIDATE(params);
if (!delegate->SetVirtualKeyboardMode(params->mode)) {
error_ = kVirtualKeyboardNotEnabled;
return false;
} else {
return true;
}
}
error_ = kNotYetImplementedError;
return false;
ExtensionFunction::ResponseAction VirtualKeyboardPrivateSetModeFunction::Run() {
std::unique_ptr<keyboard::SetMode::Params> params =
keyboard::SetMode::Params::Create(*args_);
EXTENSION_FUNCTION_VALIDATE(params);
if (!delegate()->SetVirtualKeyboardMode(params->mode))
return RespondNow(Error(kVirtualKeyboardNotEnabled));
return RespondNow(NoArguments());
}
bool VirtualKeyboardPrivateSetKeyboardStateFunction::RunSync() {
VirtualKeyboardDelegate* delegate = GetDelegate(this);
if (delegate) {
std::unique_ptr<SetRequestedKeyboardState::Params> params =
SetRequestedKeyboardState::Params::Create(*args_);
EXTENSION_FUNCTION_VALIDATE(params);
if (!delegate->SetRequestedKeyboardState(params->state)) {
error_ = kVirtualKeyboardNotEnabled;
return false;
} else {
return true;
}
}
error_ = kNotYetImplementedError;
return false;
ExtensionFunction::ResponseAction
VirtualKeyboardPrivateSetKeyboardStateFunction::Run() {
std::unique_ptr<keyboard::SetKeyboardState::Params> params =
keyboard::SetKeyboardState::Params::Create(*args_);
EXTENSION_FUNCTION_VALIDATE(params);
if (!delegate()->SetRequestedKeyboardState(params->state))
return RespondNow(Error(kVirtualKeyboardNotEnabled));
return RespondNow(NoArguments());
}
VirtualKeyboardAPI::VirtualKeyboardAPI(content::BrowserContext* context) {
delegate_ =
extensions::ExtensionsAPIClient::Get()->CreateVirtualKeyboardDelegate();
delegate_ = ExtensionsAPIClient::Get()->CreateVirtualKeyboardDelegate();
}
VirtualKeyboardAPI::~VirtualKeyboardAPI() {
......
extensions/browser/api/virtual_keyboard_private/virtual_keyboard_private_api.h
View file @ 747c4ef9
......@@ -15,7 +15,22 @@ class BrowserContext;
namespace extensions {
class VirtualKeyboardPrivateInsertTextFunction : public SyncExtensionFunction {
class VirtualKeyboardDelegate;
class VirtualKeyboardPrivateFunction : public UIThreadExtensionFunction {
public:
bool PreRunValidation(std::string* error) override;
protected:
VirtualKeyboardDelegate* delegate() { return delegate_; }
~VirtualKeyboardPrivateFunction() override;
private:
VirtualKeyboardDelegate* delegate_ = nullptr;
};
class VirtualKeyboardPrivateInsertTextFunction
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.insertText",
VIRTUALKEYBOARDPRIVATE_INSERTTEXT);
......@@ -24,11 +39,11 @@ class VirtualKeyboardPrivateInsertTextFunction : public SyncExtensionFunction {
~VirtualKeyboardPrivateInsertTextFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateSendKeyEventFunction
: public SyncExtensionFunction {
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.sendKeyEvent",
VIRTUALKEYBOARDPRIVATE_SENDKEYEVENT);
......@@ -37,11 +52,11 @@ class VirtualKeyboardPrivateSendKeyEventFunction
~VirtualKeyboardPrivateSendKeyEventFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateHideKeyboardFunction
: public SyncExtensionFunction {
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.hideKeyboard",
VIRTUALKEYBOARDPRIVATE_HIDEKEYBOARD);
......@@ -50,11 +65,11 @@ class VirtualKeyboardPrivateHideKeyboardFunction
~VirtualKeyboardPrivateHideKeyboardFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateSetHotrodKeyboardFunction
: public SyncExtensionFunction {
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.setHotrodKeyboard",
VIRTUALKEYBOARDPRIVATE_SETHOTRODKEYBOARD);
......@@ -63,11 +78,11 @@ class VirtualKeyboardPrivateSetHotrodKeyboardFunction
~VirtualKeyboardPrivateSetHotrodKeyboardFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateLockKeyboardFunction
: public SyncExtensionFunction {
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.lockKeyboard",
VIRTUALKEYBOARDPRIVATE_LOCKKEYBOARD);
......@@ -76,11 +91,11 @@ class VirtualKeyboardPrivateLockKeyboardFunction
~VirtualKeyboardPrivateLockKeyboardFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateKeyboardLoadedFunction
: public SyncExtensionFunction {
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.keyboardLoaded",
VIRTUALKEYBOARDPRIVATE_KEYBOARDLOADED);
......@@ -89,11 +104,11 @@ class VirtualKeyboardPrivateKeyboardLoadedFunction
~VirtualKeyboardPrivateKeyboardLoadedFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateGetKeyboardConfigFunction
: public SyncExtensionFunction {
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.getKeyboardConfig",
VIRTUALKEYBOARDPRIVATE_GETKEYBOARDCONFIG);
......@@ -102,11 +117,11 @@ class VirtualKeyboardPrivateGetKeyboardConfigFunction
~VirtualKeyboardPrivateGetKeyboardConfigFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateOpenSettingsFunction
: public SyncExtensionFunction {
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.openSettings",
VIRTUALKEYBOARDPRIVATE_OPENSETTINGS);
......@@ -115,10 +130,11 @@ class VirtualKeyboardPrivateOpenSettingsFunction
~VirtualKeyboardPrivateOpenSettingsFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateSetModeFunction : public SyncExtensionFunction {
class VirtualKeyboardPrivateSetModeFunction
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.setMode",
VIRTUALKEYBOARDPRIVATE_SETMODE);
......@@ -127,11 +143,11 @@ class VirtualKeyboardPrivateSetModeFunction : public SyncExtensionFunction {
~VirtualKeyboardPrivateSetModeFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardPrivateSetKeyboardStateFunction
: public SyncExtensionFunction {
: public VirtualKeyboardPrivateFunction {
public:
DECLARE_EXTENSION_FUNCTION("virtualKeyboardPrivate.setKeyboardState",
VIRTUALKEYBOARDPRIVATE_SETKEYBOARDSTATE);
......@@ -140,7 +156,7 @@ class VirtualKeyboardPrivateSetKeyboardStateFunction
~VirtualKeyboardPrivateSetKeyboardStateFunction() override {}
// ExtensionFunction:
bool RunSync() override;
ResponseAction Run() override;
};
class VirtualKeyboardDelegate;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment