src/chrome/browser/guest_view/web_view/web_view_guest.cc

   1 // Copyright 2014 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/guest_view/web_view/web_view_guest.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/chrome_notification_types.h"
  11 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
  12 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
  13 #include "chrome/browser/extensions/api/webview/webview_api.h"
  14 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
  15 #include "chrome/browser/extensions/extension_renderer_state.h"
  16 #include "chrome/browser/extensions/menu_manager.h"
  17 #include "chrome/browser/extensions/script_executor.h"
  18 #include "chrome/browser/favicon/favicon_tab_helper.h"
  19 #include "chrome/browser/geolocation/geolocation_permission_context.h"
  20 #include "chrome/browser/geolocation/geolocation_permission_context_factory.h"
  21 #include "chrome/browser/guest_view/guest_view_constants.h"
  22 #include "chrome/browser/guest_view/guest_view_manager.h"
  23 #include "chrome/browser/guest_view/web_view/web_view_constants.h"
  24 #include "chrome/browser/guest_view/web_view/web_view_permission_types.h"
  25 #include "chrome/browser/renderer_context_menu/context_menu_delegate.h"
  26 #include "chrome/browser/renderer_context_menu/render_view_context_menu.h"
  27 #include "chrome/browser/ui/pdf/pdf_tab_helper.h"
  28 #include "chrome/common/chrome_version_info.h"
  29 #include "chrome/common/render_messages.h"
  30 #include "content/public/browser/browser_thread.h"
  31 #include "content/public/browser/child_process_security_policy.h"
  32 #include "content/public/browser/host_zoom_map.h"
  33 #include "content/public/browser/native_web_keyboard_event.h"
  34 #include "content/public/browser/navigation_entry.h"
  35 #include "content/public/browser/notification_details.h"
  36 #include "content/public/browser/notification_service.h"
  37 #include "content/public/browser/notification_source.h"
  38 #include "content/public/browser/notification_types.h"
  39 #include "content/public/browser/render_process_host.h"
  40 #include "content/public/browser/render_view_host.h"
  41 #include "content/public/browser/resource_request_details.h"
  42 #include "content/public/browser/site_instance.h"
  43 #include "content/public/browser/storage_partition.h"
  44 #include "content/public/browser/user_metrics.h"
  45 #include "content/public/browser/web_contents.h"
  46 #include "content/public/browser/web_contents_delegate.h"
  47 #include "content/public/common/media_stream_request.h"
  48 #include "content/public/common/page_zoom.h"
  49 #include "content/public/common/result_codes.h"
  50 #include "content/public/common/stop_find_action.h"
  51 #include "content/public/common/url_constants.h"
  52 #include "extensions/common/constants.h"
  53 #include "ipc/ipc_message_macros.h"
  54 #include "net/base/escape.h"
  55 #include "net/base/net_errors.h"
  56 #include "third_party/WebKit/public/web/WebFindOptions.h"
  57 #include "ui/base/models/simple_menu_model.h"
  58
  59 #if defined(ENABLE_PRINTING)
  60 #if defined(ENABLE_FULL_PRINTING)
  61 #include "chrome/browser/printing/print_preview_message_handler.h"
  62 #include "chrome/browser/printing/print_view_manager.h"
  63 #else
  64 #include "chrome/browser/printing/print_view_manager_basic.h"
  65 #endif  // defined(ENABLE_FULL_PRINTING)
  66 #endif  // defined(ENABLE_PRINTING)
  67
  68 #if defined(ENABLE_PLUGINS)
  69 #include "chrome/browser/guest_view/web_view/plugin_permission_helper.h"
  70 #endif
  71
  72 #if defined(OS_CHROMEOS)
  73 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
  74 #endif
  75
  76 using base::UserMetricsAction;
  77 using content::RenderFrameHost;
  78 using content::WebContents;
  79
  80 namespace {
  81
  82 std::string WindowOpenDispositionToString(
  83   WindowOpenDisposition window_open_disposition) {
  84   switch (window_open_disposition) {
  85     case IGNORE_ACTION:
  86       return "ignore";
  87     case SAVE_TO_DISK:
  88       return "save_to_disk";
  89     case CURRENT_TAB:
  90       return "current_tab";
  91     case NEW_BACKGROUND_TAB:
  92       return "new_background_tab";
  93     case NEW_FOREGROUND_TAB:
  94       return "new_foreground_tab";
  95     case NEW_WINDOW:
  96       return "new_window";
  97     case NEW_POPUP:
  98       return "new_popup";
  99     default:
 100       NOTREACHED() << "Unknown Window Open Disposition";
 101       return "ignore";
 102   }
 103 }
 104
 105 static std::string TerminationStatusToString(base::TerminationStatus status) {
 106   switch (status) {
 107     case base::TERMINATION_STATUS_NORMAL_TERMINATION:
 108       return "normal";
 109     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
 110     case base::TERMINATION_STATUS_STILL_RUNNING:
 111       return "abnormal";
 112     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
 113       return "killed";
 114     case base::TERMINATION_STATUS_PROCESS_CRASHED:
 115 #if defined(OS_ANDROID)
 116     case base::TERMINATION_STATUS_OOM_PROTECTED:
 117 #endif
 118       return "crashed";
 119     case base::TERMINATION_STATUS_MAX_ENUM:
 120       break;
 121   }
 122   NOTREACHED() << "Unknown Termination Status.";
 123   return "unknown";
 124 }
 125
 126 static std::string PermissionTypeToString(WebViewPermissionType type) {
 127   switch (type) {
 128     case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD:
 129       return webview::kPermissionTypeDownload;
 130     case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM:
 131       return webview::kPermissionTypeFileSystem;
 132     case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
 133       return webview::kPermissionTypeGeolocation;
 134     case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
 135       return webview::kPermissionTypeDialog;
 136     case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
 137       return webview::kPermissionTypeLoadPlugin;
 138     case WEB_VIEW_PERMISSION_TYPE_MEDIA:
 139       return webview::kPermissionTypeMedia;
 140     case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW:
 141       return webview::kPermissionTypeNewWindow;
 142     case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK:
 143       return webview::kPermissionTypePointerLock;
 144     default:
 145       NOTREACHED();
 146       return std::string();
 147   }
 148 }
 149
 150 std::string GetStoragePartitionIdFromSiteURL(const GURL& site_url) {
 151   const std::string& partition_id = site_url.query();
 152   bool persist_storage = site_url.path().find("persist") != std::string::npos;
 153   return (persist_storage ? webview::kPersistPrefix : "") + partition_id;
 154 }
 155
 156 void RemoveWebViewEventListenersOnIOThread(
 157     void* profile,
 158     const std::string& extension_id,
 159     int embedder_process_id,
 160     int view_instance_id) {
 161   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 162   ExtensionWebRequestEventRouter::GetInstance()->RemoveWebViewEventListeners(
 163       profile,
 164       extension_id,
 165       embedder_process_id,
 166       view_instance_id);
 167 }
 168
 169 void AttachWebViewHelpers(WebContents* contents) {
 170   FaviconTabHelper::CreateForWebContents(contents);
 171   extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
 172       contents);
 173 #if defined(ENABLE_PLUGINS)
 174   PluginPermissionHelper::CreateForWebContents(contents);
 175 #endif
 176 #if defined(ENABLE_PRINTING)
 177 #if defined(ENABLE_FULL_PRINTING)
 178   printing::PrintViewManager::CreateForWebContents(contents);
 179   printing::PrintPreviewMessageHandler::CreateForWebContents(contents);
 180 #else
 181   printing::PrintViewManagerBasic::CreateForWebContents(contents);
 182 #endif  // defined(ENABLE_FULL_PRINTING)
 183 #endif  // defined(ENABLE_PRINTING)
 184   PDFTabHelper::CreateForWebContents(contents);
 185 }
 186
 187 }  // namespace
 188
 189 WebViewGuest::WebViewGuest(int guest_instance_id,
 190                            WebContents* guest_web_contents,
 191                            const std::string& embedder_extension_id)
 192    :  GuestView<WebViewGuest>(guest_instance_id),
 193       script_executor_(new extensions::ScriptExecutor(guest_web_contents,
 194                                                       &script_observers_)),
 195       pending_context_menu_request_id_(0),
 196       next_permission_request_id_(0),
 197       is_overriding_user_agent_(false),
 198       main_frame_id_(0),
 199       chromevox_injected_(false),
 200       find_helper_(this),
 201       javascript_dialog_helper_(this) {
 202   Init(guest_web_contents, embedder_extension_id);
 203   notification_registrar_.Add(
 204       this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
 205       content::Source<WebContents>(guest_web_contents));
 206
 207   notification_registrar_.Add(
 208       this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
 209       content::Source<WebContents>(guest_web_contents));
 210
 211 #if defined(OS_CHROMEOS)
 212   chromeos::AccessibilityManager* accessibility_manager =
 213       chromeos::AccessibilityManager::Get();
 214   CHECK(accessibility_manager);
 215   accessibility_subscription_ = accessibility_manager->RegisterCallback(
 216       base::Bind(&WebViewGuest::OnAccessibilityStatusChanged,
 217                  base::Unretained(this)));
 218 #endif
 219
 220   AttachWebViewHelpers(guest_web_contents);
 221 }
 222
 223 // static
 224 bool WebViewGuest::GetGuestPartitionConfigForSite(
 225     const GURL& site,
 226     std::string* partition_domain,
 227     std::string* partition_name,
 228     bool* in_memory) {
 229   if (!site.SchemeIs(content::kGuestScheme))
 230     return false;
 231
 232   // Since guest URLs are only used for packaged apps, there must be an app
 233   // id in the URL.
 234   CHECK(site.has_host());
 235   *partition_domain = site.host();
 236   // Since persistence is optional, the path must either be empty or the
 237   // literal string.
 238   *in_memory = (site.path() != "/persist");
 239   // The partition name is user supplied value, which we have encoded when the
 240   // URL was created, so it needs to be decoded.
 241   *partition_name =
 242       net::UnescapeURLComponent(site.query(), net::UnescapeRule::NORMAL);
 243   return true;
 244 }
 245
 246 // static
 247 const char WebViewGuest::Type[] = "webview";
 248
 249 // static
 250 int WebViewGuest::GetViewInstanceId(WebContents* contents) {
 251   WebViewGuest* guest = FromWebContents(contents);
 252   if (!guest)
 253     return guestview::kInstanceIDNone;
 254
 255   return guest->view_instance_id();
 256 }
 257
 258 // static
 259 void WebViewGuest::ParsePartitionParam(
 260     const base::DictionaryValue* extra_params,
 261     std::string* storage_partition_id,
 262     bool* persist_storage) {
 263   std::string partition_str;
 264   if (!extra_params->GetString(webview::kStoragePartitionId, &partition_str)) {
 265     return;
 266   }
 267
 268   // Since the "persist:" prefix is in ASCII, StartsWith will work fine on
 269   // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely
 270   // remove the prefix without splicing in the middle of a multi-byte codepoint.
 271   // We can use the rest of the string as UTF-8 encoded one.
 272   if (StartsWithASCII(partition_str, "persist:", true)) {
 273     size_t index = partition_str.find(":");
 274     CHECK(index != std::string::npos);
 275     // It is safe to do index + 1, since we tested for the full prefix above.
 276     *storage_partition_id = partition_str.substr(index + 1);
 277
 278     if (storage_partition_id->empty()) {
 279       // TODO(lazyboy): Better way to deal with this error.
 280       return;
 281     }
 282     *persist_storage = true;
 283   } else {
 284     *storage_partition_id = partition_str;
 285     *persist_storage = false;
 286   }
 287 }
 288
 289 // static
 290 void WebViewGuest::RecordUserInitiatedUMA(const PermissionResponseInfo& info,
 291                                           bool allow) {
 292   if (allow) {
 293     // Note that |allow| == true means the embedder explicitly allowed the
 294     // request. For some requests they might still fail. An example of such
 295     // scenario would be: an embedder allows geolocation request but doesn't
 296     // have geolocation access on its own.
 297     switch (info.permission_type) {
 298       case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD:
 299         content::RecordAction(
 300             UserMetricsAction("WebView.PermissionAllow.Download"));
 301         break;
 302       case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM:
 303         content::RecordAction(
 304             UserMetricsAction("WebView.PermissionAllow.FileSystem"));
 305         break;
 306       case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
 307         content::RecordAction(
 308             UserMetricsAction("WebView.PermissionAllow.Geolocation"));
 309         break;
 310       case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
 311         content::RecordAction(
 312             UserMetricsAction("WebView.PermissionAllow.JSDialog"));
 313         break;
 314       case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
 315         content::RecordAction(
 316             UserMetricsAction("WebView.Guest.PermissionAllow.PluginLoad"));
 317       case WEB_VIEW_PERMISSION_TYPE_MEDIA:
 318         content::RecordAction(
 319             UserMetricsAction("WebView.PermissionAllow.Media"));
 320         break;
 321       case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW:
 322         content::RecordAction(
 323             UserMetricsAction("BrowserPlugin.PermissionAllow.NewWindow"));
 324         break;
 325       case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK:
 326         content::RecordAction(
 327             UserMetricsAction("WebView.PermissionAllow.PointerLock"));
 328         break;
 329       default:
 330         break;
 331     }
 332   } else {
 333     switch (info.permission_type) {
 334       case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD:
 335         content::RecordAction(
 336             UserMetricsAction("WebView.PermissionDeny.Download"));
 337         break;
 338       case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM:
 339         content::RecordAction(
 340             UserMetricsAction("WebView.PermissionDeny.FileSystem"));
 341         break;
 342       case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
 343         content::RecordAction(
 344             UserMetricsAction("WebView.PermissionDeny.Geolocation"));
 345         break;
 346       case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
 347         content::RecordAction(
 348             UserMetricsAction("WebView.PermissionDeny.JSDialog"));
 349         break;
 350       case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
 351         content::RecordAction(
 352             UserMetricsAction("WebView.Guest.PermissionDeny.PluginLoad"));
 353         break;
 354       case WEB_VIEW_PERMISSION_TYPE_MEDIA:
 355         content::RecordAction(
 356             UserMetricsAction("WebView.PermissionDeny.Media"));
 357         break;
 358       case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW:
 359         content::RecordAction(
 360             UserMetricsAction("BrowserPlugin.PermissionDeny.NewWindow"));
 361         break;
 362       case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK:
 363         content::RecordAction(
 364             UserMetricsAction("WebView.PermissionDeny.PointerLock"));
 365         break;
 366       default:
 367         break;
 368     }
 369   }
 370 }
 371
 372 // static
 373 scoped_ptr<base::ListValue> WebViewGuest::MenuModelToValue(
 374     const ui::SimpleMenuModel& menu_model) {
 375   scoped_ptr<base::ListValue> items(new base::ListValue());
 376   for (int i = 0; i < menu_model.GetItemCount(); ++i) {
 377     base::DictionaryValue* item_value = new base::DictionaryValue();
 378     // TODO(lazyboy): We need to expose some kind of enum equivalent of
 379     // |command_id| instead of plain integers.
 380     item_value->SetInteger(webview::kMenuItemCommandId,
 381                            menu_model.GetCommandIdAt(i));
 382     item_value->SetString(webview::kMenuItemLabel, menu_model.GetLabelAt(i));
 383     items->Append(item_value);
 384   }
 385   return items.Pass();
 386 }
 387
 388 void WebViewGuest::DidAttachToEmbedder() {
 389   std::string name;
 390   if (extra_params()->GetString(webview::kName, &name)) {
 391     // If the guest window's name is empty, then the WebView tag's name is
 392     // assigned. Otherwise, the guest window's name takes precedence over the
 393     // WebView tag's name.
 394     if (name_.empty())
 395       name_ = name;
 396   }
 397   ReportFrameNameChange(name_);
 398
 399   std::string user_agent_override;
 400   if (extra_params()->GetString(webview::kParameterUserAgentOverride,
 401                                 &user_agent_override)) {
 402     SetUserAgentOverride(user_agent_override);
 403   } else {
 404     SetUserAgentOverride("");
 405   }
 406
 407   std::string src;
 408   if (extra_params()->GetString("src", &src) && !src.empty())
 409     NavigateGuest(src);
 410
 411   if (GetOpener()) {
 412     // We need to do a navigation here if the target URL has changed between
 413     // the time the WebContents was created and the time it was attached.
 414     // We also need to do an initial navigation if a RenderView was never
 415     // created for the new window in cases where there is no referrer.
 416     PendingWindowMap::iterator it =
 417         GetOpener()->pending_new_windows_.find(this);
 418     if (it != GetOpener()->pending_new_windows_.end()) {
 419       const NewWindowInfo& new_window_info = it->second;
 420       if (new_window_info.changed || !guest_web_contents()->HasOpener())
 421         NavigateGuest(new_window_info.url.spec());
 422     } else {
 423       NOTREACHED();
 424     }
 425
 426     // Once a new guest is attached to the DOM of the embedder page, then the
 427     // lifetime of the new guest is no longer managed by the opener guest.
 428     GetOpener()->pending_new_windows_.erase(this);
 429   }
 430 }
 431
 432 void WebViewGuest::DidStopLoading() {
 433   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 434   DispatchEvent(new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
 435 }
 436
 437 void WebViewGuest::EmbedderDestroyed() {
 438   // TODO(fsamuel): WebRequest event listeners for <webview> should survive
 439   // reparenting of a <webview> within a single embedder. Right now, we keep
 440   // around the browser state for the listener for the lifetime of the embedder.
 441   // Ideally, the lifetime of the listeners should match the lifetime of the
 442   // <webview> DOM node. Once http://crbug.com/156219 is resolved we can move
 443   // the call to RemoveWebViewEventListenersOnIOThread back to
 444   // WebViewGuest::WebContentsDestroyed.
 445   content::BrowserThread::PostTask(
 446       content::BrowserThread::IO,
 447       FROM_HERE,
 448       base::Bind(
 449           &RemoveWebViewEventListenersOnIOThread,
 450           browser_context(), embedder_extension_id(),
 451           embedder_render_process_id(),
 452           view_instance_id()));
 453 }
 454
 455 void WebViewGuest::GuestDestroyed() {
 456   // Clean up custom context menu items for this guest.
 457   extensions::MenuManager* menu_manager = extensions::MenuManager::Get(
 458       Profile::FromBrowserContext(browser_context()));
 459   menu_manager->RemoveAllContextItems(extensions::MenuItem::ExtensionKey(
 460       embedder_extension_id(), view_instance_id()));
 461
 462   RemoveWebViewFromExtensionRendererState(web_contents());
 463 }
 464
 465 bool WebViewGuest::IsDragAndDropEnabled() const {
 466   return true;
 467 }
 468
 469 void WebViewGuest::WillDestroy() {
 470   if (!attached() && GetOpener())
 471     GetOpener()->pending_new_windows_.erase(this);
 472   DestroyUnattachedWindows();
 473 }
 474
 475 bool WebViewGuest::AddMessageToConsole(WebContents* source,
 476                                        int32 level,
 477                                        const base::string16& message,
 478                                        int32 line_no,
 479                                        const base::string16& source_id) {
 480   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 481   // Log levels are from base/logging.h: LogSeverity.
 482   args->SetInteger(webview::kLevel, level);
 483   args->SetString(webview::kMessage, message);
 484   args->SetInteger(webview::kLine, line_no);
 485   args->SetString(webview::kSourceId, source_id);
 486   DispatchEvent(
 487       new GuestViewBase::Event(webview::kEventConsoleMessage, args.Pass()));
 488   return true;
 489 }
 490
 491 void WebViewGuest::CloseContents(WebContents* source) {
 492   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 493   DispatchEvent(new GuestViewBase::Event(webview::kEventClose, args.Pass()));
 494 }
 495
 496 void WebViewGuest::FindReply(WebContents* source,
 497                              int request_id,
 498                              int number_of_matches,
 499                              const gfx::Rect& selection_rect,
 500                              int active_match_ordinal,
 501                              bool final_update) {
 502   find_helper_.FindReply(request_id, number_of_matches, selection_rect,
 503                          active_match_ordinal, final_update);
 504 }
 505
 506 bool WebViewGuest::HandleContextMenu(
 507     const content::ContextMenuParams& params) {
 508   ContextMenuDelegate* menu_delegate =
 509       ContextMenuDelegate::FromWebContents(guest_web_contents());
 510   DCHECK(menu_delegate);
 511
 512   pending_menu_ = menu_delegate->BuildMenu(guest_web_contents(), params);
 513
 514   // Pass it to embedder.
 515   int request_id = ++pending_context_menu_request_id_;
 516   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 517   scoped_ptr<base::ListValue> items =
 518       MenuModelToValue(pending_menu_->menu_model());
 519   args->Set(webview::kContextMenuItems, items.release());
 520   args->SetInteger(webview::kRequestId, request_id);
 521   DispatchEvent(new GuestViewBase::Event(webview::kEventContextMenu,
 522                                          args.Pass()));
 523   return true;
 524 }
 525
 526 void WebViewGuest::HandleKeyboardEvent(
 527     WebContents* source,
 528     const content::NativeWebKeyboardEvent& event) {
 529   if (!attached())
 530     return;
 531
 532   if (HandleKeyboardShortcuts(event))
 533     return;
 534
 535   // Send the unhandled keyboard events back to the embedder to reprocess them.
 536   // TODO(fsamuel): This introduces the possibility of out-of-order keyboard
 537   // events because the guest may be arbitrarily delayed when responding to
 538   // keyboard events. In that time, the embedder may have received and processed
 539   // additional key events. This needs to be fixed as soon as possible.
 540   // See http://crbug.com/229882.
 541   embedder_web_contents()->GetDelegate()->HandleKeyboardEvent(
 542       web_contents(), event);
 543 }
 544
 545 void WebViewGuest::LoadProgressChanged(content::WebContents* source,
 546                                        double progress) {
 547   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 548   args->SetString(guestview::kUrl, guest_web_contents()->GetURL().spec());
 549   args->SetDouble(webview::kProgress, progress);
 550   DispatchEvent(
 551       new GuestViewBase::Event(webview::kEventLoadProgress, args.Pass()));
 552 }
 553
 554 void WebViewGuest::LoadAbort(bool is_top_level,
 555                              const GURL& url,
 556                              const std::string& error_type) {
 557   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 558   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
 559   args->SetString(guestview::kUrl, url.possibly_invalid_spec());
 560   args->SetString(guestview::kReason, error_type);
 561   DispatchEvent(
 562       new GuestViewBase::Event(webview::kEventLoadAbort, args.Pass()));
 563 }
 564
 565 void WebViewGuest::OnUpdateFrameName(bool is_top_level,
 566                                      const std::string& name) {
 567   if (!is_top_level)
 568     return;
 569
 570   if (name_ == name)
 571     return;
 572
 573   ReportFrameNameChange(name);
 574 }
 575
 576 WebViewGuest* WebViewGuest::CreateNewGuestWindow(
 577     const content::OpenURLParams& params) {
 578   GuestViewManager* guest_manager =
 579       GuestViewManager::FromBrowserContext(browser_context());
 580   // Allocate a new instance ID for the new guest.
 581   int instance_id = guest_manager->GetNextInstanceID();
 582
 583   // Set the attach params to use the same partition as the opener.
 584   // We pull the partition information from the site's URL, which is of the
 585   // form guest://site/{persist}?{partition_name}.
 586   const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL();
 587   scoped_ptr<base::DictionaryValue> create_params(extra_params()->DeepCopy());
 588   const std::string storage_partition_id =
 589       GetStoragePartitionIdFromSiteURL(site_url);
 590   create_params->SetString(webview::kStoragePartitionId, storage_partition_id);
 591
 592   WebContents* new_guest_web_contents =
 593       guest_manager->CreateGuest(guest_web_contents()->GetSiteInstance(),
 594                                  instance_id,
 595                                  create_params.Pass());
 596   WebViewGuest* new_guest =
 597       WebViewGuest::FromWebContents(new_guest_web_contents);
 598   new_guest->SetOpener(this);
 599
 600   // Take ownership of |new_guest|.
 601   pending_new_windows_.insert(
 602       std::make_pair(new_guest, NewWindowInfo(params.url, std::string())));
 603
 604   // Request permission to show the new window.
 605   RequestNewWindowPermission(params.disposition, gfx::Rect(),
 606                              params.user_gesture,
 607                              new_guest->guest_web_contents());
 608
 609   return new_guest;
 610 }
 611
 612 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
 613 // 'unresponsive' events.
 614 void WebViewGuest::RendererResponsive(content::WebContents* source) {
 615   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 616   args->SetInteger(webview::kProcessId,
 617       guest_web_contents()->GetRenderProcessHost()->GetID());
 618   DispatchEvent(
 619       new GuestViewBase::Event(webview::kEventResponsive, args.Pass()));
 620 }
 621
 622 void WebViewGuest::RendererUnresponsive(content::WebContents* source) {
 623   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 624   args->SetInteger(webview::kProcessId,
 625       guest_web_contents()->GetRenderProcessHost()->GetID());
 626   DispatchEvent(
 627       new GuestViewBase::Event(webview::kEventUnresponsive, args.Pass()));
 628 }
 629
 630 void WebViewGuest::Observe(int type,
 631                            const content::NotificationSource& source,
 632                            const content::NotificationDetails& details) {
 633   switch (type) {
 634     case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: {
 635       DCHECK_EQ(content::Source<WebContents>(source).ptr(),
 636                 guest_web_contents());
 637       if (content::Source<WebContents>(source).ptr() == guest_web_contents())
 638         LoadHandlerCalled();
 639       break;
 640     }
 641     case content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT: {
 642       DCHECK_EQ(content::Source<WebContents>(source).ptr(),
 643                 guest_web_contents());
 644       content::ResourceRedirectDetails* resource_redirect_details =
 645           content::Details<content::ResourceRedirectDetails>(details).ptr();
 646       bool is_top_level =
 647           resource_redirect_details->resource_type == ResourceType::MAIN_FRAME;
 648       LoadRedirect(resource_redirect_details->url,
 649                    resource_redirect_details->new_url,
 650                    is_top_level);
 651       break;
 652     }
 653     default:
 654       NOTREACHED() << "Unexpected notification sent.";
 655       break;
 656   }
 657 }
 658
 659 double WebViewGuest::GetZoom() {
 660   return current_zoom_factor_;
 661 }
 662
 663 void WebViewGuest::Find(
 664     const base::string16& search_text,
 665     const blink::WebFindOptions& options,
 666     scoped_refptr<extensions::WebviewFindFunction> find_function) {
 667   find_helper_.Find(guest_web_contents(), search_text, options, find_function);
 668 }
 669
 670 void WebViewGuest::StopFinding(content::StopFindAction action) {
 671   find_helper_.CancelAllFindSessions();
 672   guest_web_contents()->StopFinding(action);
 673 }
 674
 675 void WebViewGuest::Go(int relative_index) {
 676   guest_web_contents()->GetController().GoToOffset(relative_index);
 677 }
 678
 679 void WebViewGuest::Reload() {
 680   // TODO(fsamuel): Don't check for repost because we don't want to show
 681   // Chromium's repost warning. We might want to implement a separate API
 682   // for registering a callback if a repost is about to happen.
 683   guest_web_contents()->GetController().Reload(false);
 684 }
 685
 686 void WebViewGuest::RequestFileSystemPermission(
 687     const GURL& url,
 688     bool allowed_by_default,
 689     const base::Callback<void(bool)>& callback) {
 690   base::DictionaryValue request_info;
 691   request_info.Set(guestview::kUrl, base::Value::CreateStringValue(url.spec()));
 692   RequestPermission(
 693       WEB_VIEW_PERMISSION_TYPE_FILESYSTEM,
 694       request_info,
 695       base::Bind(&WebViewGuest::OnWebViewFileSystemPermissionResponse,
 696                  base::Unretained(this),
 697                  callback),
 698       allowed_by_default);
 699 }
 700
 701 void WebViewGuest::OnWebViewFileSystemPermissionResponse(
 702     const base::Callback<void(bool)>& callback,
 703     bool allow,
 704     const std::string& user_input) {
 705   callback.Run(allow && attached());
 706 }
 707
 708 void WebViewGuest::RequestGeolocationPermission(
 709     int bridge_id,
 710     const GURL& requesting_frame,
 711     bool user_gesture,
 712     const base::Callback<void(bool)>& callback) {
 713   base::DictionaryValue request_info;
 714   request_info.Set(guestview::kUrl,
 715                    base::Value::CreateStringValue(requesting_frame.spec()));
 716   request_info.Set(guestview::kUserGesture,
 717                    base::Value::CreateBooleanValue(user_gesture));
 718
 719   // It is safe to hold an unretained pointer to WebViewGuest because this
 720   // callback is called from WebViewGuest::SetPermission.
 721   const PermissionResponseCallback permission_callback =
 722       base::Bind(&WebViewGuest::OnWebViewGeolocationPermissionResponse,
 723                  base::Unretained(this),
 724                  bridge_id,
 725                  user_gesture,
 726                  callback);
 727   int request_id = RequestPermission(
 728       WEB_VIEW_PERMISSION_TYPE_GEOLOCATION,
 729       request_info,
 730       permission_callback,
 731       false /* allowed_by_default */);
 732   bridge_id_to_request_id_map_[bridge_id] = request_id;
 733 }
 734
 735 void WebViewGuest::OnWebViewGeolocationPermissionResponse(
 736     int bridge_id,
 737     bool user_gesture,
 738     const base::Callback<void(bool)>& callback,
 739     bool allow,
 740     const std::string& user_input) {
 741   // The <webview> embedder has allowed the permission. We now need to make sure
 742   // that the embedder has geolocation permission.
 743   RemoveBridgeID(bridge_id);
 744
 745   if (!allow || !attached()) {
 746     callback.Run(false);
 747     return;
 748   }
 749
 750   Profile* profile = Profile::FromBrowserContext(browser_context());
 751   GeolocationPermissionContextFactory::GetForProfile(profile)->
 752       RequestGeolocationPermission(
 753           embedder_web_contents(),
 754           // The geolocation permission request here is not initiated
 755           // through WebGeolocationPermissionRequest. We are only interested
 756           // in the fact whether the embedder/app has geolocation
 757           // permission. Therefore we use an invalid |bridge_id|.
 758           -1,
 759           embedder_web_contents()->GetLastCommittedURL(),
 760           user_gesture,
 761           callback,
 762           NULL);
 763 }
 764
 765 void WebViewGuest::CancelGeolocationPermissionRequest(int bridge_id) {
 766   int request_id = RemoveBridgeID(bridge_id);
 767   RequestMap::iterator request_itr =
 768       pending_permission_requests_.find(request_id);
 769
 770   if (request_itr == pending_permission_requests_.end())
 771     return;
 772
 773   pending_permission_requests_.erase(request_itr);
 774 }
 775
 776 void WebViewGuest::OnWebViewMediaPermissionResponse(
 777     const content::MediaStreamRequest& request,
 778     const content::MediaResponseCallback& callback,
 779     bool allow,
 780     const std::string& user_input) {
 781   if (!allow || !attached()) {
 782     // Deny the request.
 783     callback.Run(content::MediaStreamDevices(),
 784                  content::MEDIA_DEVICE_INVALID_STATE,
 785                  scoped_ptr<content::MediaStreamUI>());
 786     return;
 787   }
 788   if (!embedder_web_contents()->GetDelegate())
 789     return;
 790
 791   embedder_web_contents()->GetDelegate()->
 792       RequestMediaAccessPermission(embedder_web_contents(), request, callback);
 793 }
 794
 795 void WebViewGuest::OnWebViewDownloadPermissionResponse(
 796     const base::Callback<void(bool)>& callback,
 797     bool allow,
 798     const std::string& user_input) {
 799   callback.Run(allow && attached());
 800 }
 801
 802 void WebViewGuest::OnWebViewPointerLockPermissionResponse(
 803     const base::Callback<void(bool)>& callback,
 804     bool allow,
 805     const std::string& user_input) {
 806   callback.Run(allow && attached());
 807 }
 808
 809 WebViewGuest::SetPermissionResult WebViewGuest::SetPermission(
 810     int request_id,
 811     PermissionResponseAction action,
 812     const std::string& user_input) {
 813   RequestMap::iterator request_itr =
 814       pending_permission_requests_.find(request_id);
 815
 816   if (request_itr == pending_permission_requests_.end())
 817     return SET_PERMISSION_INVALID;
 818
 819   const PermissionResponseInfo& info = request_itr->second;
 820   bool allow = (action == ALLOW) ||
 821       ((action == DEFAULT) && info.allowed_by_default);
 822
 823   info.callback.Run(allow, user_input);
 824
 825   // Only record user initiated (i.e. non-default) actions.
 826   if (action != DEFAULT)
 827     RecordUserInitiatedUMA(info, allow);
 828
 829   pending_permission_requests_.erase(request_itr);
 830
 831   return allow ? SET_PERMISSION_ALLOWED : SET_PERMISSION_DENIED;
 832 }
 833
 834 void WebViewGuest::SetUserAgentOverride(
 835     const std::string& user_agent_override) {
 836   if (!attached())
 837     return;
 838   is_overriding_user_agent_ = !user_agent_override.empty();
 839   if (is_overriding_user_agent_) {
 840     content::RecordAction(UserMetricsAction("WebView.Guest.OverrideUA"));
 841   }
 842   guest_web_contents()->SetUserAgentOverride(user_agent_override);
 843 }
 844
 845 void WebViewGuest::Stop() {
 846   guest_web_contents()->Stop();
 847 }
 848
 849 void WebViewGuest::Terminate() {
 850   content::RecordAction(UserMetricsAction("WebView.Guest.Terminate"));
 851   base::ProcessHandle process_handle =
 852       guest_web_contents()->GetRenderProcessHost()->GetHandle();
 853   if (process_handle)
 854     base::KillProcess(process_handle, content::RESULT_CODE_KILLED, false);
 855 }
 856
 857 bool WebViewGuest::ClearData(const base::Time remove_since,
 858                              uint32 removal_mask,
 859                              const base::Closure& callback) {
 860   content::RecordAction(UserMetricsAction("WebView.Guest.ClearData"));
 861   content::StoragePartition* partition =
 862       content::BrowserContext::GetStoragePartition(
 863           guest_web_contents()->GetBrowserContext(),
 864           guest_web_contents()->GetSiteInstance());
 865
 866   if (!partition)
 867     return false;
 868
 869   partition->ClearData(
 870       removal_mask,
 871       content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
 872       GURL(),
 873       content::StoragePartition::OriginMatcherFunction(),
 874       remove_since,
 875       base::Time::Now(),
 876       callback);
 877   return true;
 878 }
 879
 880 // static
 881 void WebViewGuest::FileSystemAccessedAsync(int render_process_id,
 882                                            int render_frame_id,
 883                                            int request_id,
 884                                            const GURL& url,
 885                                            bool blocked_by_policy) {
 886   WebViewGuest* guest =
 887       WebViewGuest::FromFrameID(render_process_id, render_frame_id);
 888   DCHECK(guest);
 889   guest->RequestFileSystemPermission(
 890       url,
 891       !blocked_by_policy,
 892       base::Bind(&WebViewGuest::FileSystemAccessedAsyncResponse,
 893                  render_process_id,
 894                  render_frame_id,
 895                  request_id,
 896                  url));
 897 }
 898
 899 // static
 900 void WebViewGuest::FileSystemAccessedAsyncResponse(int render_process_id,
 901                                                    int render_frame_id,
 902                                                    int request_id,
 903                                                    const GURL& url,
 904                                                    bool allowed) {
 905   TabSpecificContentSettings::FileSystemAccessed(
 906       render_process_id, render_frame_id, url, !allowed);
 907   content::RenderFrameHost* render_frame_host =
 908       content::RenderFrameHost::FromID(render_process_id, render_frame_id);
 909   if (!render_frame_host)
 910     return;
 911   render_frame_host->Send(
 912       new ChromeViewMsg_RequestFileSystemAccessAsyncResponse(
 913           render_frame_id, request_id, allowed));
 914 }
 915
 916 // static
 917 void WebViewGuest::FileSystemAccessedSync(int render_process_id,
 918                                           int render_frame_id,
 919                                           const GURL& url,
 920                                           bool blocked_by_policy,
 921                                           IPC::Message* reply_msg) {
 922   WebViewGuest* guest =
 923       WebViewGuest::FromFrameID(render_process_id, render_frame_id);
 924   DCHECK(guest);
 925   guest->RequestFileSystemPermission(
 926       url,
 927       !blocked_by_policy,
 928       base::Bind(&WebViewGuest::FileSystemAccessedSyncResponse,
 929                  render_process_id,
 930                  render_frame_id,
 931                  url,
 932                  reply_msg));
 933 }
 934
 935 // static
 936 void WebViewGuest::FileSystemAccessedSyncResponse(int render_process_id,
 937                                                   int render_frame_id,
 938                                                   const GURL& url,
 939                                                   IPC::Message* reply_msg,
 940                                                   bool allowed) {
 941   TabSpecificContentSettings::FileSystemAccessed(
 942       render_process_id, render_frame_id, url, !allowed);
 943   ChromeViewHostMsg_RequestFileSystemAccessSync::WriteReplyParams(reply_msg,
 944                                                                   allowed);
 945   content::RenderFrameHost* render_frame_host =
 946       content::RenderFrameHost::FromID(render_process_id, render_frame_id);
 947   if (!render_frame_id)
 948     return;
 949   render_frame_host->Send(reply_msg);
 950 }
 951
 952 WebViewGuest::~WebViewGuest() {
 953 }
 954
 955 void WebViewGuest::DidCommitProvisionalLoadForFrame(
 956     int64 frame_id,
 957     const base::string16& frame_unique_name,
 958     bool is_main_frame,
 959     const GURL& url,
 960     content::PageTransition transition_type,
 961     content::RenderViewHost* render_view_host) {
 962   find_helper_.CancelAllFindSessions();
 963
 964   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 965   args->SetString(guestview::kUrl, url.spec());
 966   args->SetBoolean(guestview::kIsTopLevel, is_main_frame);
 967   args->SetInteger(webview::kInternalCurrentEntryIndex,
 968       guest_web_contents()->GetController().GetCurrentEntryIndex());
 969   args->SetInteger(webview::kInternalEntryCount,
 970       guest_web_contents()->GetController().GetEntryCount());
 971   args->SetInteger(webview::kInternalProcessId,
 972       guest_web_contents()->GetRenderProcessHost()->GetID());
 973   DispatchEvent(
 974       new GuestViewBase::Event(webview::kEventLoadCommit, args.Pass()));
 975
 976   // Update the current zoom factor for the new page.
 977   current_zoom_factor_ = content::ZoomLevelToZoomFactor(
 978       content::HostZoomMap::GetZoomLevel(guest_web_contents()));
 979
 980   if (is_main_frame) {
 981     chromevox_injected_ = false;
 982     main_frame_id_ = frame_id;
 983   }
 984 }
 985
 986 void WebViewGuest::DidFailProvisionalLoad(
 987     int64 frame_id,
 988     const base::string16& frame_unique_name,
 989     bool is_main_frame,
 990     const GURL& validated_url,
 991     int error_code,
 992     const base::string16& error_description,
 993     content::RenderViewHost* render_view_host) {
 994   // Translate the |error_code| into an error string.
 995   std::string error_type(net::ErrorToString(error_code));
 996   DCHECK(StartsWithASCII(error_type, "net::", true));
 997   error_type.erase(0, 5);
 998   LoadAbort(is_main_frame, validated_url, error_type);
 999 }
1000
1001 void WebViewGuest::DidStartProvisionalLoadForFrame(
1002     int64 frame_id,
1003     int64 parent_frame_id,
1004     bool is_main_frame,
1005     const GURL& validated_url,
1006     bool is_error_page,
1007     bool is_iframe_srcdoc,
1008     content::RenderViewHost* render_view_host) {
1009   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
1010   args->SetString(guestview::kUrl, validated_url.spec());
1011   args->SetBoolean(guestview::kIsTopLevel, is_main_frame);
1012   DispatchEvent(
1013       new GuestViewBase::Event(webview::kEventLoadStart, args.Pass()));
1014 }
1015
1016 void WebViewGuest::DocumentLoadedInFrame(
1017     int64 frame_id,
1018     content::RenderViewHost* render_view_host) {
1019   if (frame_id == main_frame_id_)
1020     InjectChromeVoxIfNeeded(render_view_host);
1021 }
1022
1023 bool WebViewGuest::OnMessageReceived(const IPC::Message& message,
1024                                      RenderFrameHost* render_frame_host) {
1025   bool handled = true;
1026   IPC_BEGIN_MESSAGE_MAP(WebViewGuest, message)
1027     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_UpdateFrameName, OnUpdateFrameName)
1028     IPC_MESSAGE_UNHANDLED(handled = false)
1029   IPC_END_MESSAGE_MAP()
1030   return handled;
1031 }
1032
1033 void WebViewGuest::RenderProcessGone(base::TerminationStatus status) {
1034   // Cancel all find sessions in progress.
1035   find_helper_.CancelAllFindSessions();
1036
1037   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
1038   args->SetInteger(webview::kProcessId,
1039                    guest_web_contents()->GetRenderProcessHost()->GetID());
1040   args->SetString(webview::kReason, TerminationStatusToString(status));
1041   DispatchEvent(new GuestViewBase::Event(webview::kEventExit, args.Pass()));
1042 }
1043
1044 void WebViewGuest::UserAgentOverrideSet(const std::string& user_agent) {
1045   if (!attached())
1046     return;
1047   content::NavigationController& controller =
1048       guest_web_contents()->GetController();
1049   content::NavigationEntry* entry = controller.GetVisibleEntry();
1050   if (!entry)
1051     return;
1052   entry->SetIsOverridingUserAgent(!user_agent.empty());
1053   guest_web_contents()->GetController().Reload(false);
1054 }
1055
1056 void WebViewGuest::RenderViewReady() {
1057   // The guest RenderView should always live in an isolated guest process.
1058   CHECK(guest_web_contents()->GetRenderProcessHost()->IsIsolatedGuest());
1059   Send(new ChromeViewMsg_SetName(guest_web_contents()->GetRoutingID(), name_));
1060 }
1061
1062 void WebViewGuest::ReportFrameNameChange(const std::string& name) {
1063   name_ = name;
1064   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
1065   args->SetString(webview::kName, name);
1066   DispatchEvent(
1067       new GuestViewBase::Event(webview::kEventFrameNameChanged, args.Pass()));
1068 }
1069
1070 void WebViewGuest::LoadHandlerCalled() {
1071   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
1072   DispatchEvent(
1073       new GuestViewBase::Event(webview::kEventContentLoad, args.Pass()));
1074 }
1075
1076 void WebViewGuest::LoadRedirect(const GURL& old_url,
1077                                 const GURL& new_url,
1078                                 bool is_top_level) {
1079   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
1080   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
1081   args->SetString(webview::kNewURL, new_url.spec());
1082   args->SetString(webview::kOldURL, old_url.spec());
1083   DispatchEvent(
1084       new GuestViewBase::Event(webview::kEventLoadRedirect, args.Pass()));
1085 }
1086
1087 void WebViewGuest::AddWebViewToExtensionRendererState() {
1088   const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL();
1089   std::string partition_domain;
1090   std::string partition_id;
1091   bool in_memory;
1092   if (!GetGuestPartitionConfigForSite(
1093           site_url, &partition_domain, &partition_id, &in_memory)) {
1094     NOTREACHED();
1095     return;
1096   }
1097   DCHECK(embedder_extension_id() == partition_domain);
1098
1099   ExtensionRendererState::WebViewInfo web_view_info;
1100   web_view_info.embedder_process_id = embedder_render_process_id();
1101   web_view_info.instance_id = view_instance_id();
1102   web_view_info.partition_id = partition_id;
1103   web_view_info.embedder_extension_id = embedder_extension_id();
1104
1105   content::BrowserThread::PostTask(
1106       content::BrowserThread::IO,
1107       FROM_HERE,
1108       base::Bind(&ExtensionRendererState::AddWebView,
1109                  base::Unretained(ExtensionRendererState::GetInstance()),
1110                  guest_web_contents()->GetRenderProcessHost()->GetID(),
1111                  guest_web_contents()->GetRoutingID(),
1112                  web_view_info));
1113 }
1114
1115 // static
1116 void WebViewGuest::RemoveWebViewFromExtensionRendererState(
1117     WebContents* web_contents) {
1118   content::BrowserThread::PostTask(
1119       content::BrowserThread::IO, FROM_HERE,
1120       base::Bind(
1121           &ExtensionRendererState::RemoveWebView,
1122           base::Unretained(ExtensionRendererState::GetInstance()),
1123           web_contents->GetRenderProcessHost()->GetID(),
1124           web_contents->GetRoutingID()));
1125 }
1126
1127 void WebViewGuest::SizeChanged(const gfx::Size& old_size,
1128                                const gfx::Size& new_size) {
1129   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
1130   args->SetInteger(webview::kOldHeight, old_size.height());
1131   args->SetInteger(webview::kOldWidth, old_size.width());
1132   args->SetInteger(webview::kNewHeight, new_size.height());
1133   args->SetInteger(webview::kNewWidth, new_size.width());
1134   DispatchEvent(
1135       new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
1136 }
1137
1138 void WebViewGuest::RequestMediaAccessPermission(
1139     content::WebContents* source,
1140     const content::MediaStreamRequest& request,
1141     const content::MediaResponseCallback& callback) {
1142   base::DictionaryValue request_info;
1143   request_info.Set(
1144       guestview::kUrl,
1145       base::Value::CreateStringValue(request.security_origin.spec()));
1146   RequestPermission(WEB_VIEW_PERMISSION_TYPE_MEDIA,
1147                     request_info,
1148                     base::Bind(&WebViewGuest::OnWebViewMediaPermissionResponse,
1149                                base::Unretained(this),
1150                                request,
1151                                callback),
1152                     false /* allowed_by_default */);
1153 }
1154
1155 void WebViewGuest::CanDownload(
1156     content::RenderViewHost* render_view_host,
1157     const GURL& url,
1158     const std::string& request_method,
1159     const base::Callback<void(bool)>& callback) {
1160   base::DictionaryValue request_info;
1161   request_info.Set(
1162       guestview::kUrl,
1163       base::Value::CreateStringValue(url.spec()));
1164   RequestPermission(
1165       WEB_VIEW_PERMISSION_TYPE_DOWNLOAD,
1166       request_info,
1167       base::Bind(&WebViewGuest::OnWebViewDownloadPermissionResponse,
1168                  base::Unretained(this),
1169                  callback),
1170       false /* allowed_by_default */);
1171 }
1172
1173 void WebViewGuest::RequestPointerLockPermission(
1174     bool user_gesture,
1175     bool last_unlocked_by_target,
1176     const base::Callback<void(bool)>& callback) {
1177   base::DictionaryValue request_info;
1178   request_info.Set(guestview::kUserGesture,
1179                    base::Value::CreateBooleanValue(user_gesture));
1180   request_info.Set(webview::kLastUnlockedBySelf,
1181                    base::Value::CreateBooleanValue(last_unlocked_by_target));
1182   request_info.Set(guestview::kUrl,
1183                    base::Value::CreateStringValue(
1184                        guest_web_contents()->GetLastCommittedURL().spec()));
1185
1186   RequestPermission(
1187       WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK,
1188       request_info,
1189       base::Bind(&WebViewGuest::OnWebViewPointerLockPermissionResponse,
1190                  base::Unretained(this),
1191                  callback),
1192       false /* allowed_by_default */);
1193 }
1194
1195 void WebViewGuest::WillAttachToEmbedder() {
1196   // We must install the mapping from guests to WebViews prior to resuming
1197   // suspended resource loads so that the WebRequest API will catch resource
1198   // requests.
1199   AddWebViewToExtensionRendererState();
1200 }
1201
1202 content::JavaScriptDialogManager*
1203     WebViewGuest::GetJavaScriptDialogManager() {
1204   return &javascript_dialog_helper_;
1205 }
1206
1207 content::ColorChooser* WebViewGuest::OpenColorChooser(
1208     WebContents* web_contents,
1209     SkColor color,
1210     const std::vector<content::ColorSuggestion>& suggestions) {
1211   if (!attached() || !embedder_web_contents()->GetDelegate())
1212     return NULL;
1213   return embedder_web_contents()->GetDelegate()->OpenColorChooser(
1214       web_contents, color, suggestions);
1215 }
1216
1217 void WebViewGuest::RunFileChooser(WebContents* web_contents,
1218                                   const content::FileChooserParams& params) {
1219   if (!attached() || !embedder_web_contents()->GetDelegate())
1220     return;
1221
1222   embedder_web_contents()->GetDelegate()->RunFileChooser(web_contents, params);
1223 }
1224
1225 void WebViewGuest::NavigateGuest(const std::string& src) {
1226   GURL url = ResolveURL(src);
1227
1228   // Do not allow navigating a guest to schemes other than known safe schemes.
1229   // This will block the embedder trying to load unwanted schemes, e.g.
1230   // chrome://settings.
1231   bool scheme_is_blocked =
1232       (!content::ChildProcessSecurityPolicy::GetInstance()->IsWebSafeScheme(
1233            url.scheme()) &&
1234        !url.SchemeIs(url::kAboutScheme)) ||
1235       url.SchemeIs(url::kJavaScriptScheme);
1236   if (scheme_is_blocked || !url.is_valid()) {
1237     std::string error_type(net::ErrorToString(net::ERR_ABORTED));
1238     DCHECK(StartsWithASCII(error_type, "net::", true));
1239     error_type.erase(0, 5);
1240     LoadAbort(true /* is_top_level */, url, error_type);
1241     return;
1242   }
1243
1244   GURL validated_url(url);
1245   guest_web_contents()->GetRenderProcessHost()->
1246       FilterURL(false, &validated_url);
1247   // As guests do not swap processes on navigation, only navigations to
1248   // normal web URLs are supported.  No protocol handlers are installed for
1249   // other schemes (e.g., WebUI or extensions), and no permissions or bindings
1250   // can be granted to the guest process.
1251   LoadURLWithParams(validated_url,
1252                     content::Referrer(),
1253                     content::PAGE_TRANSITION_AUTO_TOPLEVEL,
1254                     guest_web_contents());
1255 }
1256
1257 #if defined(OS_CHROMEOS)
1258 void WebViewGuest::OnAccessibilityStatusChanged(
1259     const chromeos::AccessibilityStatusEventDetails& details) {
1260   if (details.notification_type == chromeos::ACCESSIBILITY_MANAGER_SHUTDOWN) {
1261     accessibility_subscription_.reset();
1262   } else if (details.notification_type ==
1263       chromeos::ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK) {
1264     if (details.enabled)
1265       InjectChromeVoxIfNeeded(guest_web_contents()->GetRenderViewHost());
1266     else
1267       chromevox_injected_ = false;
1268   }
1269 }
1270 #endif
1271
1272 void WebViewGuest::InjectChromeVoxIfNeeded(
1273     content::RenderViewHost* render_view_host) {
1274 #if defined(OS_CHROMEOS)
1275   if (!chromevox_injected_) {
1276     chromeos::AccessibilityManager* manager =
1277         chromeos::AccessibilityManager::Get();
1278     if (manager && manager->IsSpokenFeedbackEnabled()) {
1279       manager->InjectChromeVox(render_view_host);
1280       chromevox_injected_ = true;
1281     }
1282   }
1283 #endif
1284 }
1285
1286 int WebViewGuest::RemoveBridgeID(int bridge_id) {
1287   std::map<int, int>::iterator bridge_itr =
1288       bridge_id_to_request_id_map_.find(bridge_id);
1289   if (bridge_itr == bridge_id_to_request_id_map_.end())
1290     return webview::kInvalidPermissionRequestID;
1291
1292   int request_id = bridge_itr->second;
1293   bridge_id_to_request_id_map_.erase(bridge_itr);
1294   return request_id;
1295 }
1296
1297 int WebViewGuest::RequestPermission(
1298     WebViewPermissionType permission_type,
1299     const base::DictionaryValue& request_info,
1300     const PermissionResponseCallback& callback,
1301     bool allowed_by_default) {
1302   // If there are too many pending permission requests then reject this request.
1303   if (pending_permission_requests_.size() >=
1304       webview::kMaxOutstandingPermissionRequests) {
1305     // Let the stack unwind before we deny the permission request so that
1306     // objects held by the permission request are not destroyed immediately
1307     // after creation. This is to allow those same objects to be accessed again
1308     // in the same scope without fear of use after freeing.
1309     base::MessageLoop::current()->PostTask(
1310         FROM_HERE,
1311         base::Bind(&PermissionResponseCallback::Run,
1312                   base::Owned(new PermissionResponseCallback(callback)),
1313                   allowed_by_default,
1314                   std::string()));
1315     return webview::kInvalidPermissionRequestID;
1316   }
1317
1318   int request_id = next_permission_request_id_++;
1319   pending_permission_requests_[request_id] =
1320       PermissionResponseInfo(callback, permission_type, allowed_by_default);
1321   scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy());
1322   args->SetInteger(webview::kRequestId, request_id);
1323   switch (permission_type) {
1324     case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: {
1325       DispatchEvent(
1326           new GuestViewBase::Event(webview::kEventNewWindow, args.Pass()));
1327       break;
1328     }
1329     case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: {
1330       DispatchEvent(
1331           new GuestViewBase::Event(webview::kEventDialog, args.Pass()));
1332       break;
1333     }
1334     default: {
1335       args->SetString(webview::kPermission,
1336                       PermissionTypeToString(permission_type));
1337       DispatchEvent(new GuestViewBase::Event(webview::kEventPermissionRequest,
1338                                              args.Pass()));
1339       break;
1340     }
1341   }
1342   return request_id;
1343 }
1344
1345 bool WebViewGuest::HandleKeyboardShortcuts(
1346     const content::NativeWebKeyboardEvent& event) {
1347   if (event.type != blink::WebInputEvent::RawKeyDown)
1348     return false;
1349
1350   // If the user hits the escape key without any modifiers then unlock the
1351   // mouse if necessary.
1352   if ((event.windowsKeyCode == ui::VKEY_ESCAPE) &&
1353       !(event.modifiers & blink::WebInputEvent::InputModifiers)) {
1354     return guest_web_contents()->GotResponseToLockMouseRequest(false);
1355   }
1356
1357 #if defined(OS_MACOSX)
1358   if (event.modifiers != blink::WebInputEvent::MetaKey)
1359     return false;
1360
1361   if (event.windowsKeyCode == ui::VKEY_OEM_4) {
1362     Go(-1);
1363     return true;
1364   }
1365
1366   if (event.windowsKeyCode == ui::VKEY_OEM_6) {
1367     Go(1);
1368     return true;
1369   }
1370 #else
1371   if (event.windowsKeyCode == ui::VKEY_BROWSER_BACK) {
1372     Go(-1);
1373     return true;
1374   }
1375
1376   if (event.windowsKeyCode == ui::VKEY_BROWSER_FORWARD) {
1377     Go(1);
1378     return true;
1379   }
1380 #endif
1381
1382   return false;
1383 }
1384
1385 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo()
1386     : permission_type(WEB_VIEW_PERMISSION_TYPE_UNKNOWN),
1387       allowed_by_default(false) {
1388 }
1389
1390 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo(
1391     const PermissionResponseCallback& callback,
1392     WebViewPermissionType permission_type,
1393     bool allowed_by_default)
1394     : callback(callback),
1395       permission_type(permission_type),
1396       allowed_by_default(allowed_by_default) {
1397 }
1398
1399 WebViewGuest::PermissionResponseInfo::~PermissionResponseInfo() {
1400 }
1401
1402 void WebViewGuest::ShowContextMenu(int request_id,
1403                                    const MenuItemVector* items) {
1404   if (!pending_menu_.get())
1405     return;
1406
1407   // Make sure this was the correct request.
1408   if (request_id != pending_context_menu_request_id_)
1409     return;
1410
1411   // TODO(lazyboy): Implement.
1412   DCHECK(!items);
1413
1414   ContextMenuDelegate* menu_delegate =
1415       ContextMenuDelegate::FromWebContents(guest_web_contents());
1416   menu_delegate->ShowMenu(pending_menu_.Pass());
1417 }
1418
1419 void WebViewGuest::SetName(const std::string& name) {
1420   if (name_ == name)
1421     return;
1422   name_ = name;
1423
1424   Send(new ChromeViewMsg_SetName(routing_id(), name_));
1425 }
1426
1427 void WebViewGuest::SetZoom(double zoom_factor) {
1428   double zoom_level = content::ZoomFactorToZoomLevel(zoom_factor);
1429   content::HostZoomMap::SetZoomLevel(guest_web_contents(), zoom_level);
1430
1431   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
1432   args->SetDouble(webview::kOldZoomFactor, current_zoom_factor_);
1433   args->SetDouble(webview::kNewZoomFactor, zoom_factor);
1434   DispatchEvent(
1435       new GuestViewBase::Event(webview::kEventZoomChange, args.Pass()));
1436
1437   current_zoom_factor_ = zoom_factor;
1438 }
1439
1440 void WebViewGuest::AddNewContents(content::WebContents* source,
1441                                   content::WebContents* new_contents,
1442                                   WindowOpenDisposition disposition,
1443                                   const gfx::Rect& initial_pos,
1444                                   bool user_gesture,
1445                                   bool* was_blocked) {
1446   if (was_blocked)
1447     *was_blocked = false;
1448   RequestNewWindowPermission(disposition,
1449                              initial_pos,
1450                              user_gesture,
1451                              new_contents);
1452 }
1453
1454 content::WebContents* WebViewGuest::OpenURLFromTab(
1455     content::WebContents* source,
1456     const content::OpenURLParams& params) {
1457   // If the guest wishes to navigate away prior to attachment then we save the
1458   // navigation to perform upon attachment. Navigation initializes a lot of
1459   // state that assumes an embedder exists, such as RenderWidgetHostViewGuest.
1460   // Navigation also resumes resource loading which we don't want to allow
1461   // until attachment.
1462   if (!attached()) {
1463     WebViewGuest* opener = GetOpener();
1464     PendingWindowMap::iterator it =
1465         opener->pending_new_windows_.find(this);
1466     if (it == opener->pending_new_windows_.end())
1467       return NULL;
1468     const NewWindowInfo& info = it->second;
1469     NewWindowInfo new_window_info(params.url, info.name);
1470     new_window_info.changed = new_window_info.url != info.url;
1471     it->second = new_window_info;
1472     return NULL;
1473   }
1474   if (params.disposition == CURRENT_TAB) {
1475     // This can happen for cross-site redirects.
1476     LoadURLWithParams(params.url, params.referrer, params.transition, source);
1477     return source;
1478   }
1479
1480   return CreateNewGuestWindow(params)->guest_web_contents();
1481 }
1482
1483 void WebViewGuest::WebContentsCreated(WebContents* source_contents,
1484                                       int opener_render_frame_id,
1485                                       const base::string16& frame_name,
1486                                       const GURL& target_url,
1487                                       content::WebContents* new_contents) {
1488   WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents);
1489   CHECK(guest);
1490   guest->SetOpener(this);
1491   std::string guest_name = base::UTF16ToUTF8(frame_name);
1492   guest->name_ = guest_name;
1493   pending_new_windows_.insert(
1494       std::make_pair(guest, NewWindowInfo(target_url, guest_name)));
1495 }
1496
1497 void WebViewGuest::LoadURLWithParams(const GURL& url,
1498                                      const content::Referrer& referrer,
1499                                      content::PageTransition transition_type,
1500                                      content::WebContents* web_contents) {
1501   content::NavigationController::LoadURLParams load_url_params(url);
1502   load_url_params.referrer = referrer;
1503   load_url_params.transition_type = transition_type;
1504   load_url_params.extra_headers = std::string();
1505   if (is_overriding_user_agent_) {
1506     load_url_params.override_user_agent =
1507         content::NavigationController::UA_OVERRIDE_TRUE;
1508   }
1509   web_contents->GetController().LoadURLWithParams(load_url_params);
1510 }
1511
1512 void WebViewGuest::RequestNewWindowPermission(
1513     WindowOpenDisposition disposition,
1514     const gfx::Rect& initial_bounds,
1515     bool user_gesture,
1516     content::WebContents* new_contents) {
1517   WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents);
1518   if (!guest)
1519     return;
1520   PendingWindowMap::iterator it = pending_new_windows_.find(guest);
1521   if (it == pending_new_windows_.end())
1522     return;
1523   const NewWindowInfo& new_window_info = it->second;
1524
1525   // Retrieve the opener partition info if we have it.
1526   const GURL& site_url = new_contents->GetSiteInstance()->GetSiteURL();
1527   std::string storage_partition_id = GetStoragePartitionIdFromSiteURL(site_url);
1528
1529   base::DictionaryValue request_info;
1530   request_info.Set(webview::kInitialHeight,
1531                    base::Value::CreateIntegerValue(initial_bounds.height()));
1532   request_info.Set(webview::kInitialWidth,
1533                    base::Value::CreateIntegerValue(initial_bounds.width()));
1534   request_info.Set(webview::kTargetURL,
1535                    base::Value::CreateStringValue(new_window_info.url.spec()));
1536   request_info.Set(webview::kName,
1537                    base::Value::CreateStringValue(new_window_info.name));
1538   request_info.Set(webview::kWindowID,
1539                    base::Value::CreateIntegerValue(guest->guest_instance_id()));
1540   // We pass in partition info so that window-s created through newwindow
1541   // API can use it to set their partition attribute.
1542   request_info.Set(webview::kStoragePartitionId,
1543                    base::Value::CreateStringValue(storage_partition_id));
1544   request_info.Set(webview::kWindowOpenDisposition,
1545                    base::Value::CreateStringValue(
1546                        WindowOpenDispositionToString(disposition)));
1547
1548   RequestPermission(WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW,
1549                     request_info,
1550                     base::Bind(&WebViewGuest::OnWebViewNewWindowResponse,
1551                                base::Unretained(this),
1552                                guest->guest_instance_id()),
1553                                false /* allowed_by_default */);
1554 }
1555
1556 void WebViewGuest::DestroyUnattachedWindows() {
1557   // Destroy() reaches in and removes the WebViewGuest from its opener's
1558   // pending_new_windows_ set. To avoid mutating the set while iterating, we
1559   // create a copy of the pending new windows set and iterate over the copy.
1560   PendingWindowMap pending_new_windows(pending_new_windows_);
1561   // Clean up unattached new windows opened by this guest.
1562   for (PendingWindowMap::const_iterator it = pending_new_windows.begin();
1563        it != pending_new_windows.end(); ++it) {
1564     it->first->Destroy();
1565   }
1566   // All pending windows should be removed from the set after Destroy() is
1567   // called on all of them.
1568   DCHECK(pending_new_windows_.empty());
1569 }
1570
1571 GURL WebViewGuest::ResolveURL(const std::string& src) {
1572   if (!in_extension()) {
1573     NOTREACHED();
1574     return GURL(src);
1575   }
1576
1577   GURL default_url(base::StringPrintf("%s://%s/",
1578                                       extensions::kExtensionScheme,
1579                                       embedder_extension_id().c_str()));
1580   return default_url.Resolve(src);
1581 }
1582
1583 void WebViewGuest::OnWebViewNewWindowResponse(
1584     int new_window_instance_id,
1585     bool allow,
1586     const std::string& user_input) {
1587   WebViewGuest* guest =
1588       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
1589   if (!guest)
1590     return;
1591
1592   if (!allow)
1593     guest->Destroy();
1594 }