src/chrome/browser/extensions/api/webview/webview_api.cc

   1 // Copyright (c) 2013 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/webview/webview_api.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "chrome/browser/extensions/api/browsing_data/browsing_data_api.h"
   9 #include "chrome/browser/extensions/api/context_menus/context_menus_api.h"
  10 #include "chrome/browser/extensions/api/context_menus/context_menus_api_helpers.h"
  11 #include "chrome/browser/extensions/tab_helper.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/common/extensions/api/webview.h"
  14 #include "content/public/browser/render_process_host.h"
  15 #include "content/public/browser/render_view_host.h"
  16 #include "content/public/browser/storage_partition.h"
  17 #include "content/public/browser/web_contents.h"
  18 #include "content/public/common/stop_find_action.h"
  19 #include "extensions/common/error_utils.h"
  20 #include "third_party/WebKit/public/web/WebFindOptions.h"
  21
  22 using content::WebContents;
  23 using extensions::api::tabs::InjectDetails;
  24 using extensions::api::webview::SetPermission::Params;
  25 namespace helpers = extensions::context_menus_api_helpers;
  26 namespace webview = extensions::api::webview;
  27
  28 namespace extensions {
  29
  30 namespace {
  31 int MaskForKey(const char* key) {
  32   if (strcmp(key, extension_browsing_data_api_constants::kAppCacheKey) == 0)
  33     return content::StoragePartition::REMOVE_DATA_MASK_APPCACHE;
  34   if (strcmp(key, extension_browsing_data_api_constants::kCookiesKey) == 0)
  35     return content::StoragePartition::REMOVE_DATA_MASK_COOKIES;
  36   if (strcmp(key, extension_browsing_data_api_constants::kFileSystemsKey) == 0)
  37     return content::StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
  38   if (strcmp(key, extension_browsing_data_api_constants::kIndexedDBKey) == 0)
  39     return content::StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
  40   if (strcmp(key, extension_browsing_data_api_constants::kLocalStorageKey) == 0)
  41     return content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
  42   if (strcmp(key, extension_browsing_data_api_constants::kWebSQLKey) == 0)
  43     return content::StoragePartition::REMOVE_DATA_MASK_WEBSQL;
  44   return 0;
  45 }
  46
  47 }  // namespace
  48
  49 bool WebviewExtensionFunction::RunAsync() {
  50   int instance_id = 0;
  51   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &instance_id));
  52   WebViewGuest* guest = WebViewGuest::From(
  53       render_view_host()->GetProcess()->GetID(), instance_id);
  54   if (!guest)
  55     return false;
  56
  57   return RunAsyncSafe(guest);
  58 }
  59
  60 // TODO(lazyboy): Add checks similar to
  61 // WebviewExtensionFunction::RunAsyncSafe(WebViewGuest*).
  62 bool WebviewContextMenusCreateFunction::RunAsync() {
  63   scoped_ptr<webview::ContextMenusCreate::Params> params(
  64       webview::ContextMenusCreate::Params::Create(*args_));
  65   EXTENSION_FUNCTION_VALIDATE(params.get());
  66
  67   MenuItem::Id id(
  68       Profile::FromBrowserContext(browser_context())->IsOffTheRecord(),
  69       MenuItem::ExtensionKey(extension_id(), params->instance_id));
  70
  71   if (params->create_properties.id.get()) {
  72     id.string_uid = *params->create_properties.id;
  73   } else {
  74     // The Generated Id is added by webview_custom_bindings.js.
  75     base::DictionaryValue* properties = NULL;
  76     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &properties));
  77     EXTENSION_FUNCTION_VALIDATE(
  78         properties->GetInteger(helpers::kGeneratedIdKey, &id.uid));
  79   }
  80
  81   bool success = extensions::context_menus_api_helpers::CreateMenuItem(
  82       params->create_properties,
  83       Profile::FromBrowserContext(browser_context()),
  84       GetExtension(),
  85       id,
  86       &error_);
  87
  88   SendResponse(success);
  89   return success;
  90 }
  91
  92 bool WebviewNavigateFunction::RunAsyncSafe(WebViewGuest* guest) {
  93   scoped_ptr<webview::Navigate::Params> params(
  94       webview::Navigate::Params::Create(*args_));
  95   EXTENSION_FUNCTION_VALIDATE(params.get());
  96   std::string src = params->src;
  97   guest->NavigateGuest(src);
  98   return true;
  99 }
 100
 101 bool WebviewContextMenusUpdateFunction::RunAsync() {
 102   scoped_ptr<webview::ContextMenusUpdate::Params> params(
 103       webview::ContextMenusUpdate::Params::Create(*args_));
 104   EXTENSION_FUNCTION_VALIDATE(params.get());
 105
 106   Profile* profile = Profile::FromBrowserContext(browser_context());
 107   MenuItem::Id item_id(
 108       profile->IsOffTheRecord(),
 109       MenuItem::ExtensionKey(extension_id(), params->instance_id));
 110
 111   if (params->id.as_string)
 112     item_id.string_uid = *params->id.as_string;
 113   else if (params->id.as_integer)
 114     item_id.uid = *params->id.as_integer;
 115   else
 116     NOTREACHED();
 117
 118   bool success = extensions::context_menus_api_helpers::UpdateMenuItem(
 119       params->update_properties, profile, GetExtension(), item_id, &error_);
 120   SendResponse(success);
 121   return success;
 122 }
 123
 124 bool WebviewContextMenusRemoveFunction::RunAsync() {
 125   scoped_ptr<webview::ContextMenusRemove::Params> params(
 126       webview::ContextMenusRemove::Params::Create(*args_));
 127   EXTENSION_FUNCTION_VALIDATE(params.get());
 128
 129   MenuManager* menu_manager =
 130       MenuManager::Get(Profile::FromBrowserContext(browser_context()));
 131
 132   MenuItem::Id id(
 133       Profile::FromBrowserContext(browser_context())->IsOffTheRecord(),
 134       MenuItem::ExtensionKey(extension_id(), params->instance_id));
 135
 136   if (params->menu_item_id.as_string) {
 137     id.string_uid = *params->menu_item_id.as_string;
 138   } else if (params->menu_item_id.as_integer) {
 139     id.uid = *params->menu_item_id.as_integer;
 140   } else {
 141     NOTREACHED();
 142   }
 143
 144   bool success = true;
 145   MenuItem* item = menu_manager->GetItemById(id);
 146   // Ensure one <webview> can't remove another's menu items.
 147   if (!item || item->id().extension_key != id.extension_key) {
 148     error_ = ErrorUtils::FormatErrorMessage(
 149         context_menus_api_helpers::kCannotFindItemError,
 150         context_menus_api_helpers::GetIDString(id));
 151     success = false;
 152   } else if (!menu_manager->RemoveContextMenuItem(id)) {
 153     success = false;
 154   }
 155
 156   SendResponse(success);
 157   return success;
 158 }
 159
 160 bool WebviewContextMenusRemoveAllFunction::RunAsync() {
 161   scoped_ptr<webview::ContextMenusRemoveAll::Params> params(
 162       webview::ContextMenusRemoveAll::Params::Create(*args_));
 163   EXTENSION_FUNCTION_VALIDATE(params.get());
 164
 165   MenuManager* menu_manager =
 166       MenuManager::Get(Profile::FromBrowserContext(browser_context()));
 167
 168   int webview_instance_id = params->instance_id;
 169   menu_manager->RemoveAllContextItems(
 170       MenuItem::ExtensionKey(GetExtension()->id(), webview_instance_id));
 171   SendResponse(true);
 172   return true;
 173 }
 174
 175 WebviewClearDataFunction::WebviewClearDataFunction()
 176     : remove_mask_(0), bad_message_(false) {}
 177
 178 WebviewClearDataFunction::~WebviewClearDataFunction() {}
 179
 180 // Parses the |dataToRemove| argument to generate the remove mask. Sets
 181 // |bad_message_| (like EXTENSION_FUNCTION_VALIDATE would if this were a bool
 182 // method) if 'dataToRemove' is not present.
 183 uint32 WebviewClearDataFunction::GetRemovalMask() {
 184   base::DictionaryValue* data_to_remove;
 185   if (!args_->GetDictionary(2, &data_to_remove)) {
 186     bad_message_ = true;
 187     return 0;
 188   }
 189
 190   uint32 remove_mask = 0;
 191   for (base::DictionaryValue::Iterator i(*data_to_remove);
 192        !i.IsAtEnd();
 193        i.Advance()) {
 194     bool selected = false;
 195     if (!i.value().GetAsBoolean(&selected)) {
 196       bad_message_ = true;
 197       return 0;
 198     }
 199     if (selected)
 200       remove_mask |= MaskForKey(i.key().c_str());
 201   }
 202
 203   return remove_mask;
 204 }
 205
 206 // TODO(lazyboy): Parameters in this extension function are similar (or a
 207 // sub-set) to BrowsingDataRemoverFunction. How can we share this code?
 208 bool WebviewClearDataFunction::RunAsyncSafe(WebViewGuest* guest) {
 209   // Grab the initial |options| parameter, and parse out the arguments.
 210   base::DictionaryValue* options;
 211   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &options));
 212   DCHECK(options);
 213
 214   // If |ms_since_epoch| isn't set, default it to 0.
 215   double ms_since_epoch;
 216   if (!options->GetDouble(extension_browsing_data_api_constants::kSinceKey,
 217                           &ms_since_epoch)) {
 218     ms_since_epoch = 0;
 219   }
 220
 221   // base::Time takes a double that represents seconds since epoch. JavaScript
 222   // gives developers milliseconds, so do a quick conversion before populating
 223   // the object. Also, Time::FromDoubleT converts double time 0 to empty Time
 224   // object. So we need to do special handling here.
 225   remove_since_ = (ms_since_epoch == 0) ?
 226       base::Time::UnixEpoch() :
 227       base::Time::FromDoubleT(ms_since_epoch / 1000.0);
 228
 229   remove_mask_ = GetRemovalMask();
 230   if (bad_message_)
 231     return false;
 232
 233   AddRef();  // Balanced below or in WebviewClearDataFunction::Done().
 234
 235   bool scheduled = false;
 236   if (remove_mask_) {
 237     scheduled = guest->ClearData(
 238         remove_since_,
 239         remove_mask_,
 240         base::Bind(&WebviewClearDataFunction::ClearDataDone,
 241                    this));
 242   }
 243   if (!remove_mask_ || !scheduled) {
 244     SendResponse(false);
 245     Release();  // Balanced above.
 246     return false;
 247   }
 248
 249   // Will finish asynchronously.
 250   return true;
 251 }
 252
 253 void WebviewClearDataFunction::ClearDataDone() {
 254   Release();  // Balanced in RunAsync().
 255   SendResponse(true);
 256 }
 257
 258 WebviewExecuteCodeFunction::WebviewExecuteCodeFunction()
 259     : guest_instance_id_(0), guest_src_(GURL::EmptyGURL()) {}
 260
 261 WebviewExecuteCodeFunction::~WebviewExecuteCodeFunction() {
 262 }
 263
 264 bool WebviewExecuteCodeFunction::Init() {
 265   if (details_.get())
 266     return true;
 267
 268   if (!args_->GetInteger(0, &guest_instance_id_))
 269     return false;
 270
 271   if (!guest_instance_id_)
 272     return false;
 273
 274   std::string src;
 275   if (!args_->GetString(1, &src))
 276     return false;
 277
 278   guest_src_ = GURL(src);
 279   if (!guest_src_.is_valid())
 280     return false;
 281
 282   base::DictionaryValue* details_value = NULL;
 283   if (!args_->GetDictionary(2, &details_value))
 284     return false;
 285   scoped_ptr<InjectDetails> details(new InjectDetails());
 286   if (!InjectDetails::Populate(*details_value, details.get()))
 287     return false;
 288
 289   details_ = details.Pass();
 290   return true;
 291 }
 292
 293 bool WebviewExecuteCodeFunction::ShouldInsertCSS() const {
 294   return false;
 295 }
 296
 297 bool WebviewExecuteCodeFunction::CanExecuteScriptOnPage() {
 298   return true;
 299 }
 300
 301 extensions::ScriptExecutor* WebviewExecuteCodeFunction::GetScriptExecutor() {
 302   WebViewGuest* guest = WebViewGuest::From(
 303       render_view_host()->GetProcess()->GetID(), guest_instance_id_);
 304   if (!guest)
 305     return NULL;
 306
 307   return guest->script_executor();
 308 }
 309
 310 bool WebviewExecuteCodeFunction::IsWebView() const {
 311   return true;
 312 }
 313
 314 const GURL& WebviewExecuteCodeFunction::GetWebViewSrc() const {
 315   return guest_src_;
 316 }
 317
 318 WebviewExecuteScriptFunction::WebviewExecuteScriptFunction() {
 319 }
 320
 321 void WebviewExecuteScriptFunction::OnExecuteCodeFinished(
 322     const std::string& error,
 323     int32 on_page_id,
 324     const GURL& on_url,
 325     const base::ListValue& result) {
 326   if (error.empty())
 327     SetResult(result.DeepCopy());
 328   WebviewExecuteCodeFunction::OnExecuteCodeFinished(error, on_page_id, on_url,
 329                                                     result);
 330 }
 331
 332 WebviewInsertCSSFunction::WebviewInsertCSSFunction() {
 333 }
 334
 335 bool WebviewInsertCSSFunction::ShouldInsertCSS() const {
 336   return true;
 337 }
 338
 339 WebviewCaptureVisibleRegionFunction::WebviewCaptureVisibleRegionFunction() {
 340 }
 341
 342 WebviewCaptureVisibleRegionFunction::~WebviewCaptureVisibleRegionFunction() {
 343 }
 344
 345 bool WebviewCaptureVisibleRegionFunction::IsScreenshotEnabled() {
 346   return true;
 347 }
 348
 349 WebContents* WebviewCaptureVisibleRegionFunction::GetWebContentsForID(
 350     int instance_id) {
 351   WebViewGuest* guest = WebViewGuest::From(
 352       render_view_host()->GetProcess()->GetID(), instance_id);
 353   return guest ? guest->guest_web_contents() : NULL;
 354 }
 355
 356 void WebviewCaptureVisibleRegionFunction::OnCaptureFailure(
 357     FailureReason reason) {
 358   SendResponse(false);
 359 }
 360
 361 WebviewSetNameFunction::WebviewSetNameFunction() {
 362 }
 363
 364 WebviewSetNameFunction::~WebviewSetNameFunction() {
 365 }
 366
 367 WebviewSetZoomFunction::WebviewSetZoomFunction() {
 368 }
 369
 370 WebviewSetZoomFunction::~WebviewSetZoomFunction() {
 371 }
 372
 373 bool WebviewSetNameFunction::RunAsyncSafe(WebViewGuest* guest) {
 374   scoped_ptr<webview::SetName::Params> params(
 375       webview::SetName::Params::Create(*args_));
 376   EXTENSION_FUNCTION_VALIDATE(params.get());
 377   guest->SetName(params->frame_name);
 378   SendResponse(true);
 379   return true;
 380 }
 381
 382 bool WebviewSetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
 383   scoped_ptr<webview::SetZoom::Params> params(
 384       webview::SetZoom::Params::Create(*args_));
 385   EXTENSION_FUNCTION_VALIDATE(params.get());
 386   guest->SetZoom(params->zoom_factor);
 387
 388   SendResponse(true);
 389   return true;
 390 }
 391
 392 WebviewGetZoomFunction::WebviewGetZoomFunction() {
 393 }
 394
 395 WebviewGetZoomFunction::~WebviewGetZoomFunction() {
 396 }
 397
 398 bool WebviewGetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
 399   scoped_ptr<webview::GetZoom::Params> params(
 400       webview::GetZoom::Params::Create(*args_));
 401   EXTENSION_FUNCTION_VALIDATE(params.get());
 402
 403   double zoom_factor = guest->GetZoom();
 404   SetResult(base::Value::CreateDoubleValue(zoom_factor));
 405   SendResponse(true);
 406   return true;
 407 }
 408
 409 WebviewFindFunction::WebviewFindFunction() {
 410 }
 411
 412 WebviewFindFunction::~WebviewFindFunction() {
 413 }
 414
 415 bool WebviewFindFunction::RunAsyncSafe(WebViewGuest* guest) {
 416   scoped_ptr<webview::Find::Params> params(
 417       webview::Find::Params::Create(*args_));
 418   EXTENSION_FUNCTION_VALIDATE(params.get());
 419
 420   // Convert the std::string search_text to string16.
 421   base::string16 search_text;
 422   base::UTF8ToUTF16(params->search_text.c_str(),
 423                     params->search_text.length(),
 424                     &search_text);
 425
 426   // Set the find options to their default values.
 427   blink::WebFindOptions options;
 428   if (params->options) {
 429     options.forward =
 430         params->options->backward ? !*params->options->backward : true;
 431     options.matchCase =
 432         params->options->match_case ? *params->options->match_case : false;
 433   }
 434
 435   guest->Find(search_text, options, this);
 436   return true;
 437 }
 438
 439 WebviewStopFindingFunction::WebviewStopFindingFunction() {
 440 }
 441
 442 WebviewStopFindingFunction::~WebviewStopFindingFunction() {
 443 }
 444
 445 bool WebviewStopFindingFunction::RunAsyncSafe(WebViewGuest* guest) {
 446   scoped_ptr<webview::StopFinding::Params> params(
 447       webview::StopFinding::Params::Create(*args_));
 448   EXTENSION_FUNCTION_VALIDATE(params.get());
 449
 450   // Set the StopFindAction.
 451   content::StopFindAction action;
 452   switch (params->action) {
 453     case webview::StopFinding::Params::ACTION_CLEAR:
 454       action = content::STOP_FIND_ACTION_CLEAR_SELECTION;
 455       break;
 456     case webview::StopFinding::Params::ACTION_KEEP:
 457       action = content::STOP_FIND_ACTION_KEEP_SELECTION;
 458       break;
 459     case webview::StopFinding::Params::ACTION_ACTIVATE:
 460       action = content::STOP_FIND_ACTION_ACTIVATE_SELECTION;
 461       break;
 462     default:
 463       action = content::STOP_FIND_ACTION_KEEP_SELECTION;
 464   }
 465
 466   guest->StopFinding(action);
 467   return true;
 468 }
 469
 470 WebviewGoFunction::WebviewGoFunction() {
 471 }
 472
 473 WebviewGoFunction::~WebviewGoFunction() {
 474 }
 475
 476 bool WebviewGoFunction::RunAsyncSafe(WebViewGuest* guest) {
 477   scoped_ptr<webview::Go::Params> params(webview::Go::Params::Create(*args_));
 478   EXTENSION_FUNCTION_VALIDATE(params.get());
 479
 480   guest->Go(params->relative_index);
 481   return true;
 482 }
 483
 484 WebviewReloadFunction::WebviewReloadFunction() {
 485 }
 486
 487 WebviewReloadFunction::~WebviewReloadFunction() {
 488 }
 489
 490 bool WebviewReloadFunction::RunAsyncSafe(WebViewGuest* guest) {
 491   guest->Reload();
 492   return true;
 493 }
 494
 495 WebviewSetPermissionFunction::WebviewSetPermissionFunction() {
 496 }
 497
 498 WebviewSetPermissionFunction::~WebviewSetPermissionFunction() {
 499 }
 500
 501 bool WebviewSetPermissionFunction::RunAsyncSafe(WebViewGuest* guest) {
 502   scoped_ptr<webview::SetPermission::Params> params(
 503       webview::SetPermission::Params::Create(*args_));
 504   EXTENSION_FUNCTION_VALIDATE(params.get());
 505
 506   WebViewGuest::PermissionResponseAction action = WebViewGuest::DEFAULT;
 507   switch (params->action) {
 508     case Params::ACTION_ALLOW:
 509       action = WebViewGuest::ALLOW;
 510       break;
 511     case Params::ACTION_DENY:
 512       action = WebViewGuest::DENY;
 513       break;
 514     case Params::ACTION_DEFAULT:
 515       break;
 516     default:
 517       NOTREACHED();
 518   }
 519
 520   std::string user_input;
 521   if (params->user_input)
 522     user_input = *params->user_input;
 523
 524   WebViewGuest::SetPermissionResult result =
 525       guest->SetPermission(params->request_id, action, user_input);
 526
 527   EXTENSION_FUNCTION_VALIDATE(result != WebViewGuest::SET_PERMISSION_INVALID);
 528
 529   SetResult(base::Value::CreateBooleanValue(
 530       result == WebViewGuest::SET_PERMISSION_ALLOWED));
 531   SendResponse(true);
 532   return true;
 533 }
 534
 535 WebviewShowContextMenuFunction::WebviewShowContextMenuFunction() {
 536 }
 537
 538 WebviewShowContextMenuFunction::~WebviewShowContextMenuFunction() {
 539 }
 540
 541 bool WebviewShowContextMenuFunction::RunAsyncSafe(WebViewGuest* guest) {
 542   scoped_ptr<webview::ShowContextMenu::Params> params(
 543       webview::ShowContextMenu::Params::Create(*args_));
 544   EXTENSION_FUNCTION_VALIDATE(params.get());
 545
 546   // TODO(lazyboy): Actually implement filtering menu items, we pass NULL for
 547   // now.
 548   guest->ShowContextMenu(params->request_id, NULL);
 549
 550   SendResponse(true);
 551   return true;
 552 }
 553
 554 WebviewOverrideUserAgentFunction::WebviewOverrideUserAgentFunction() {
 555 }
 556
 557 WebviewOverrideUserAgentFunction::~WebviewOverrideUserAgentFunction() {
 558 }
 559
 560 bool WebviewOverrideUserAgentFunction::RunAsyncSafe(WebViewGuest* guest) {
 561   scoped_ptr<extensions::api::webview::OverrideUserAgent::Params> params(
 562       extensions::api::webview::OverrideUserAgent::Params::Create(*args_));
 563   EXTENSION_FUNCTION_VALIDATE(params.get());
 564
 565   guest->SetUserAgentOverride(params->user_agent_override);
 566   return true;
 567 }
 568
 569 WebviewStopFunction::WebviewStopFunction() {
 570 }
 571
 572 WebviewStopFunction::~WebviewStopFunction() {
 573 }
 574
 575 bool WebviewStopFunction::RunAsyncSafe(WebViewGuest* guest) {
 576   guest->Stop();
 577   return true;
 578 }
 579
 580 WebviewTerminateFunction::WebviewTerminateFunction() {
 581 }
 582
 583 WebviewTerminateFunction::~WebviewTerminateFunction() {
 584 }
 585
 586 bool WebviewTerminateFunction::RunAsyncSafe(WebViewGuest* guest) {
 587   guest->Terminate();
 588   return true;
 589 }
 590
 591 }  // namespace extensions