src/chrome/browser/extensions/api/declarative/declarative_api.cc

   1 // Copyright (c) 2012 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 "chrome/browser/extensions/api/declarative/declarative_api.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/task_runner_util.h"
  10 #include "base/values.h"
  11 #include "chrome/browser/extensions/api/declarative/rules_registry_service.h"
  12 #include "chrome/browser/guest_view/web_view/web_view_constants.h"
  13 #include "chrome/browser/guest_view/web_view/web_view_guest.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/common/extensions/api/events.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #include "content/public/browser/render_process_host.h"
  18 #include "content/public/browser/render_view_host.h"
  19 #include "extensions/browser/extension_system.h"
  20 #include "extensions/common/extension_api.h"
  21 #include "extensions/common/permissions/permissions_data.h"
  22
  23 using extensions::api::events::Rule;
  24
  25 namespace AddRules = extensions::api::events::Event::AddRules;
  26 namespace GetRules = extensions::api::events::Event::GetRules;
  27 namespace RemoveRules = extensions::api::events::Event::RemoveRules;
  28
  29
  30 namespace extensions {
  31
  32 namespace {
  33
  34 const char kWebRequest[] = "declarativeWebRequest.";
  35 const char kWebViewExpectedError[] = "Webview event with Webview ID expected.";
  36
  37 bool IsWebViewEvent(const std::string& event_name) {
  38   // Sample event names:
  39   // webViewInternal.onRequest.
  40   // webViewInternal.onMessage.
  41   return event_name.compare(0,
  42                             strlen(webview::kWebViewEventPrefix),
  43                             webview::kWebViewEventPrefix) == 0;
  44 }
  45
  46 std::string GetWebRequestEventName(const std::string& event_name) {
  47   std::string web_request_event_name(event_name);
  48   if (IsWebViewEvent(web_request_event_name)) {
  49     web_request_event_name.replace(
  50         0, strlen(webview::kWebViewEventPrefix), kWebRequest);
  51   }
  52   return web_request_event_name;
  53 }
  54
  55 }  // namespace
  56
  57 RulesFunction::RulesFunction()
  58     : rules_registry_(NULL) {
  59 }
  60
  61 RulesFunction::~RulesFunction() {}
  62
  63 bool RulesFunction::HasPermission() {
  64   std::string event_name;
  65   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
  66   if (IsWebViewEvent(event_name) &&
  67       extension_->permissions_data()->HasAPIPermission(
  68           extensions::APIPermission::kWebView))
  69     return true;
  70   Feature::Availability availability =
  71       ExtensionAPI::GetSharedInstance()->IsAvailable(
  72           event_name, extension_, Feature::BLESSED_EXTENSION_CONTEXT,
  73           source_url());
  74   return availability.is_available();
  75 }
  76
  77 bool RulesFunction::RunAsync() {
  78   std::string event_name;
  79   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
  80
  81   int webview_instance_id = 0;
  82   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(1, &webview_instance_id));
  83   int embedder_process_id = render_view_host()->GetProcess()->GetID();
  84
  85   bool has_webview = webview_instance_id != 0;
  86   if (has_webview != IsWebViewEvent(event_name))
  87     EXTENSION_FUNCTION_ERROR(kWebViewExpectedError);
  88   event_name = GetWebRequestEventName(event_name);
  89
  90   // If we are not operating on a particular <webview>, then the key is (0, 0).
  91   RulesRegistryService::WebViewKey key(
  92       webview_instance_id ? embedder_process_id : 0, webview_instance_id);
  93
  94   RulesRegistryService* rules_registry_service =
  95       RulesRegistryService::Get(GetProfile());
  96   rules_registry_ = rules_registry_service->GetRulesRegistry(key, event_name);
  97   // Raw access to this function is not available to extensions, therefore
  98   // there should never be a request for a nonexisting rules registry.
  99   EXTENSION_FUNCTION_VALIDATE(rules_registry_.get());
 100
 101   if (content::BrowserThread::CurrentlyOn(rules_registry_->owner_thread())) {
 102     bool success = RunAsyncOnCorrectThread();
 103     SendResponse(success);
 104   } else {
 105     scoped_refptr<base::MessageLoopProxy> message_loop_proxy =
 106         content::BrowserThread::GetMessageLoopProxyForThread(
 107             rules_registry_->owner_thread());
 108     base::PostTaskAndReplyWithResult(
 109         message_loop_proxy.get(),
 110         FROM_HERE,
 111         base::Bind(&RulesFunction::RunAsyncOnCorrectThread, this),
 112         base::Bind(&RulesFunction::SendResponse, this));
 113   }
 114
 115   return true;
 116 }
 117
 118 bool EventsEventAddRulesFunction::RunAsyncOnCorrectThread() {
 119   scoped_ptr<AddRules::Params> params(AddRules::Params::Create(*args_));
 120   EXTENSION_FUNCTION_VALIDATE(params.get());
 121
 122   error_ = rules_registry_->AddRules(extension_id(), params->rules);
 123
 124   if (error_.empty())
 125     results_ = AddRules::Results::Create(params->rules);
 126
 127   return error_.empty();
 128 }
 129
 130 bool EventsEventRemoveRulesFunction::RunAsyncOnCorrectThread() {
 131   scoped_ptr<RemoveRules::Params> params(RemoveRules::Params::Create(*args_));
 132   EXTENSION_FUNCTION_VALIDATE(params.get());
 133
 134   if (params->rule_identifiers.get()) {
 135     error_ = rules_registry_->RemoveRules(extension_id(),
 136                                           *params->rule_identifiers);
 137   } else {
 138     error_ = rules_registry_->RemoveAllRules(extension_id());
 139   }
 140
 141   return error_.empty();
 142 }
 143
 144 bool EventsEventGetRulesFunction::RunAsyncOnCorrectThread() {
 145   scoped_ptr<GetRules::Params> params(GetRules::Params::Create(*args_));
 146   EXTENSION_FUNCTION_VALIDATE(params.get());
 147
 148   std::vector<linked_ptr<Rule> > rules;
 149   if (params->rule_identifiers.get()) {
 150     rules_registry_->GetRules(
 151         extension_id(), *params->rule_identifiers, &rules);
 152   } else {
 153     rules_registry_->GetAllRules(extension_id(), &rules);
 154   }
 155
 156   results_ = GetRules::Results::Create(rules);
 157
 158   return true;
 159 }
 160
 161 }  // namespace extensions