[Extensions] declarative API function -> UIThreadExtensionFunction

AsynExtensionFunction is deprecated and will soon be removed.

Bug: 829174
Change-Id: I1201a74737fff8846f0847e1a2ae1c3963d96af9
Reviewed-on: https://chromium-review.googlesource.com/997099
Commit-Queue: Istiaque Ahmed <lazyboy@chromium.org>
Reviewed-by: Devlin <rdevlin.cronin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#548506}

extensions/browser/api/declarative/declarative_api.cc

@@ -139,29 +139,23 @@ RulesFunction::RulesFunction() {}
 
 RulesFunction::~RulesFunction() {}
 
-bool RulesFunction::HasPermission() {
+ExtensionFunction::ResponseAction RulesFunction::Run() {
+  EXTENSION_FUNCTION_VALIDATE(CreateParams());
+
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
+
   int web_view_instance_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(1, &web_view_instance_id));
 
   // <webview> embedders use the declarativeWebRequest API via
   // <webview>.onRequest.
-  if (web_view_instance_id && extension_->permissions_data()->HasAPIPermission(
+  if (web_view_instance_id && !extension_->permissions_data()->HasAPIPermission(
                                   APIPermission::kWebView)) {
-    return true;
+    return RespondNow(Error("Missing webview permission"));
   }
-  return ExtensionFunction::HasPermission();
-}
 
-bool RulesFunction::RunAsync() {
-  std::string event_name;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
-
-  int web_view_instance_id = 0;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(1, &web_view_instance_id));
   int embedder_process_id = render_frame_host()->GetProcess()->GetID();
-
   RecordUMA(event_name);
 
   bool from_web_view = web_view_instance_id != 0;
@@ -189,43 +183,50 @@ bool RulesFunction::RunAsync() {
   // there should never be a request for a nonexisting rules registry.
   EXTENSION_FUNCTION_VALIDATE(rules_registry_.get());
 
-  if (content::BrowserThread::CurrentlyOn(rules_registry_->owner_thread())) {
-    bool success = RunAsyncOnCorrectThread();
-    SendResponse(success);
-  } else {
+  if (content::BrowserThread::CurrentlyOn(rules_registry_->owner_thread()))
+    return RespondNow(RunAsyncOnCorrectThread());
+
   scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner =
       content::BrowserThread::GetTaskRunnerForThread(
           rules_registry_->owner_thread());
   base::PostTaskAndReplyWithResult(
       thread_task_runner.get(), FROM_HERE,
-        base::Bind(&RulesFunction::RunAsyncOnCorrectThread, this),
-        base::Bind(&RulesFunction::SendResponse, this));
-  }
+      base::BindOnce(&RulesFunction::RunAsyncOnCorrectThread, this),
+      base::BindOnce(&RulesFunction::SendResponse, this));
+  return RespondLater();
+}
 
-  return true;
+void RulesFunction::SendResponse(ResponseValue response) {
+  Respond(std::move(response));
 }
 
-bool EventsEventAddRulesFunction::RunAsyncOnCorrectThread() {
+EventsEventAddRulesFunction::EventsEventAddRulesFunction() = default;
+
+EventsEventAddRulesFunction::~EventsEventAddRulesFunction() = default;
+
+bool EventsEventAddRulesFunction::CreateParams() {
+  params_ = AddRules::Params::Create(*args_);
+  return params_ != nullptr;
+}
+
+ExtensionFunction::ResponseValue
+EventsEventAddRulesFunction::RunAsyncOnCorrectThread() {
   ConvertBinaryListElementsToBase64(args_.get());
-  std::unique_ptr<AddRules::Params> params(AddRules::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // TODO(devlin): Remove the dependency on linked_ptr here.
   std::vector<linked_ptr<api::events::Rule>> linked_rules;
-  for (api::events::Rule& rule : params->rules) {
+  for (api::events::Rule& rule : params_->rules) {
     linked_rules.push_back(
         make_linked_ptr(new api::events::Rule(std::move(rule))));
   }
-  error_ = rules_registry_->AddRules(extension_id(), linked_rules);
+  std::string error = rules_registry_->AddRules(extension_id(), linked_rules);
+  if (!error.empty())
+    return Error(error);
 
-  if (error_.empty()) {
-    std::unique_ptr<base::ListValue> rules_value(new base::ListValue());
+  auto rules_value = std::make_unique<base::ListValue>();
   for (const auto& rule : linked_rules)
     rules_value->Append(rule->ToValue());
-    SetResult(std::move(rules_value));
-  }
-
-  return error_.empty();
+  return OneArgument(std::move(rules_value));
 }
 
 void EventsEventAddRulesFunction::RecordUMA(
@@ -248,19 +249,26 @@ void EventsEventAddRulesFunction::RecordUMA(
   RecordUMAHelper(type);
 }
 
-bool EventsEventRemoveRulesFunction::RunAsyncOnCorrectThread() {
-  std::unique_ptr<RemoveRules::Params> params(
-      RemoveRules::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
+EventsEventRemoveRulesFunction::EventsEventRemoveRulesFunction() = default;
+
+EventsEventRemoveRulesFunction::~EventsEventRemoveRulesFunction() = default;
 
-  if (params->rule_identifiers.get()) {
-    error_ = rules_registry_->RemoveRules(extension_id(),
-                                          *params->rule_identifiers);
+bool EventsEventRemoveRulesFunction::CreateParams() {
+  params_ = RemoveRules::Params::Create(*args_);
+  return params_ != nullptr;
+}
+
+ExtensionFunction::ResponseValue
+EventsEventRemoveRulesFunction::RunAsyncOnCorrectThread() {
+  std::string error;
+  if (params_->rule_identifiers.get()) {
+    error = rules_registry_->RemoveRules(extension_id(),
+                                         *params_->rule_identifiers);
   } else {
-    error_ = rules_registry_->RemoveAllRules(extension_id());
+    error = rules_registry_->RemoveAllRules(extension_id());
   }
 
-  return error_.empty();
+  return error.empty() ? NoArguments() : Error(error);
 }
 
 void EventsEventRemoveRulesFunction::RecordUMA(
@@ -283,24 +291,29 @@ void EventsEventRemoveRulesFunction::RecordUMA(
   RecordUMAHelper(type);
 }
 
-bool EventsEventGetRulesFunction::RunAsyncOnCorrectThread() {
-  std::unique_ptr<GetRules::Params> params(GetRules::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
+EventsEventGetRulesFunction::EventsEventGetRulesFunction() = default;
+
+EventsEventGetRulesFunction::~EventsEventGetRulesFunction() = default;
 
+bool EventsEventGetRulesFunction::CreateParams() {
+  params_ = GetRules::Params::Create(*args_);
+  return params_ != nullptr;
+}
+
+ExtensionFunction::ResponseValue
+EventsEventGetRulesFunction::RunAsyncOnCorrectThread() {
   std::vector<linked_ptr<Rule> > rules;
-  if (params->rule_identifiers.get()) {
-    rules_registry_->GetRules(
-        extension_id(), *params->rule_identifiers, &rules);
+  if (params_->rule_identifiers.get()) {
+    rules_registry_->GetRules(extension_id(), *params_->rule_identifiers,
+                              &rules);
   } else {
     rules_registry_->GetAllRules(extension_id(), &rules);
   }
 
-  std::unique_ptr<base::ListValue> rules_value(new base::ListValue());
+  auto rules_value = std::make_unique<base::ListValue>();
   for (const auto& rule : rules)
     rules_value->Append(rule->ToValue());
-  SetResult(std::move(rules_value));
-
-  return true;
+  return OneArgument(std::move(rules_value));
 }
 
 void EventsEventGetRulesFunction::RecordUMA(

extensions/browser/api/declarative/declarative_api.h

@@ -13,7 +13,23 @@
 
 namespace extensions {
 
-class RulesFunction : public AsyncExtensionFunction {
+namespace api {
+namespace events {
+namespace Event {
+namespace AddRules {
+struct Params;
+}  // namespace AddRules
+namespace GetRules {
+struct Params;
+}  // namespace GetRules
+namespace RemoveRules {
+struct Params;
+}  // namespace RemoveRules
+}  // namespace Event
+}  // namespace events
+}  // namespace api
+
+class RulesFunction : public UIThreadExtensionFunction {
  public:
   RulesFunction();
 
@@ -21,54 +37,80 @@ class RulesFunction : public AsyncExtensionFunction {
   ~RulesFunction() override;
 
   // ExtensionFunction:
-  bool HasPermission() override;
-  bool RunAsync() override;
+  ResponseAction Run() override;
+
+  // Returns whether or not params creation succeeded, the result is used to
+  // validate params.
+  virtual bool CreateParams() = 0;
 
   // Concrete implementation of the RulesFunction that is being called
   // on the thread on which the respective RulesRegistry lives.
   // Returns false in case of errors.
-  virtual bool RunAsyncOnCorrectThread() = 0;
+  virtual ResponseValue RunAsyncOnCorrectThread() = 0;
 
   // Records UMA metrics for the kind of declarative API call.
   virtual void RecordUMA(const std::string& event_name) const = 0;
 
   scoped_refptr<RulesRegistry> rules_registry_;
+
+ private:
+  void SendResponse(ResponseValue response);
+
+  DISALLOW_COPY_AND_ASSIGN(RulesFunction);
 };
 
 class EventsEventAddRulesFunction : public RulesFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("events.addRules", EVENTS_ADDRULES)
 
+  EventsEventAddRulesFunction();
+
  protected:
-  ~EventsEventAddRulesFunction() override {}
+  ~EventsEventAddRulesFunction() override;
 
   // RulesFunction:
-  bool RunAsyncOnCorrectThread() override;
+  bool CreateParams() override;
+  ResponseValue RunAsyncOnCorrectThread() override;
   void RecordUMA(const std::string& event_name) const override;
+
+ private:
+  std::unique_ptr<api::events::Event::AddRules::Params> params_;
 };
 
 class EventsEventRemoveRulesFunction : public RulesFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("events.removeRules", EVENTS_REMOVERULES)
 
+  EventsEventRemoveRulesFunction();
+
  protected:
-  ~EventsEventRemoveRulesFunction() override {}
+  ~EventsEventRemoveRulesFunction() override;
 
   // RulesFunction:
-  bool RunAsyncOnCorrectThread() override;
+  bool CreateParams() override;
+  ResponseValue RunAsyncOnCorrectThread() override;
   void RecordUMA(const std::string& event_name) const override;
+
+ private:
+  std::unique_ptr<api::events::Event::RemoveRules::Params> params_;
 };
 
 class EventsEventGetRulesFunction : public RulesFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("events.getRules", EVENTS_GETRULES)
 
+  EventsEventGetRulesFunction();
+
  protected:
-  ~EventsEventGetRulesFunction() override {}
+  ~EventsEventGetRulesFunction() override;
 
   // RulesFunction:
-  bool RunAsyncOnCorrectThread() override;
+  bool CreateParams() override;
+  ResponseValue RunAsyncOnCorrectThread() override;
   void RecordUMA(const std::string& event_name) const override;
+
+ private:
+  std::unique_ptr<api::events::Event::GetRules::Params> params_;
 };
 
 }  // namespace extensions