Home | History | Annotate | Download | only in web_view 
      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 "extensions/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 "content/public/browser/browser_context.h"
     11 #include "content/public/browser/browser_thread.h"
     12 #include "content/public/browser/child_process_security_policy.h"
     13 #include "content/public/browser/native_web_keyboard_event.h"
     14 #include "content/public/browser/navigation_entry.h"
     15 #include "content/public/browser/notification_details.h"
     16 #include "content/public/browser/notification_service.h"
     17 #include "content/public/browser/notification_source.h"
     18 #include "content/public/browser/notification_types.h"
     19 #include "content/public/browser/render_process_host.h"
     20 #include "content/public/browser/render_view_host.h"
     21 #include "content/public/browser/render_widget_host_view.h"
     22 #include "content/public/browser/resource_request_details.h"
     23 #include "content/public/browser/site_instance.h"
     24 #include "content/public/browser/storage_partition.h"
     25 #include "content/public/browser/user_metrics.h"
     26 #include "content/public/browser/web_contents.h"
     27 #include "content/public/browser/web_contents_delegate.h"
     28 #include "content/public/common/media_stream_request.h"
     29 #include "content/public/common/page_zoom.h"
     30 #include "content/public/common/result_codes.h"
     31 #include "content/public/common/stop_find_action.h"
     32 #include "content/public/common/url_constants.h"
     33 #include "extensions/browser/api/extensions_api_client.h"
     34 #include "extensions/browser/api/web_view/web_view_internal_api.h"
     35 #include "extensions/browser/extension_system.h"
     36 #include "extensions/browser/guest_view/guest_view_manager.h"
     37 #include "extensions/browser/guest_view/web_view/web_view_constants.h"
     38 #include "extensions/browser/guest_view/web_view/web_view_permission_helper.h"
     39 #include "extensions/browser/guest_view/web_view/web_view_permission_types.h"
     40 #include "extensions/browser/guest_view/web_view/web_view_renderer_state.h"
     41 #include "extensions/common/constants.h"
     42 #include "extensions/common/extension_messages.h"
     43 #include "extensions/common/guest_view/guest_view_constants.h"
     44 #include "extensions/strings/grit/extensions_strings.h"
     45 #include "ipc/ipc_message_macros.h"
     46 #include "net/base/escape.h"
     47 #include "net/base/net_errors.h"
     48 #include "ui/base/models/simple_menu_model.h"
     49 
     50 using base::UserMetricsAction;
     51 using content::RenderFrameHost;
     52 using content::ResourceType;
     53 using content::WebContents;
     54 
     55 namespace extensions {
     56 
     57 namespace {
     58 
     59 std::string WindowOpenDispositionToString(
     60   WindowOpenDisposition window_open_disposition) {
     61   switch (window_open_disposition) {
     62     case IGNORE_ACTION:
     63       return "ignore";
     64     case SAVE_TO_DISK:
     65       return "save_to_disk";
     66     case CURRENT_TAB:
     67       return "current_tab";
     68     case NEW_BACKGROUND_TAB:
     69       return "new_background_tab";
     70     case NEW_FOREGROUND_TAB:
     71       return "new_foreground_tab";
     72     case NEW_WINDOW:
     73       return "new_window";
     74     case NEW_POPUP:
     75       return "new_popup";
     76     default:
     77       NOTREACHED() << "Unknown Window Open Disposition";
     78       return "ignore";
     79   }
     80 }
     81 
     82 static std::string TerminationStatusToString(base::TerminationStatus status) {
     83   switch (status) {
     84     case base::TERMINATION_STATUS_NORMAL_TERMINATION:
     85       return "normal";
     86     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
     87     case base::TERMINATION_STATUS_STILL_RUNNING:
     88       return "abnormal";
     89     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
     90       return "killed";
     91     case base::TERMINATION_STATUS_PROCESS_CRASHED:
     92       return "crashed";
     93     case base::TERMINATION_STATUS_MAX_ENUM:
     94       break;
     95   }
     96   NOTREACHED() << "Unknown Termination Status.";
     97   return "unknown";
     98 }
     99 
    100 std::string GetStoragePartitionIdFromSiteURL(const GURL& site_url) {
    101   const std::string& partition_id = site_url.query();
    102   bool persist_storage = site_url.path().find("persist") != std::string::npos;
    103   return (persist_storage ? webview::kPersistPrefix : "") + partition_id;
    104 }
    105 
    106 void ParsePartitionParam(const base::DictionaryValue& create_params,
    107                          std::string* storage_partition_id,
    108                          bool* persist_storage) {
    109   std::string partition_str;
    110   if (!create_params.GetString(webview::kStoragePartitionId, &partition_str)) {
    111     return;
    112   }
    113 
    114   // Since the "persist:" prefix is in ASCII, StartsWith will work fine on
    115   // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely
    116   // remove the prefix without splicing in the middle of a multi-byte codepoint.
    117   // We can use the rest of the string as UTF-8 encoded one.
    118   if (StartsWithASCII(partition_str, "persist:", true)) {
    119     size_t index = partition_str.find(":");
    120     CHECK(index != std::string::npos);
    121     // It is safe to do index + 1, since we tested for the full prefix above.
    122     *storage_partition_id = partition_str.substr(index + 1);
    123 
    124     if (storage_partition_id->empty()) {
    125       // TODO(lazyboy): Better way to deal with this error.
    126       return;
    127     }
    128     *persist_storage = true;
    129   } else {
    130     *storage_partition_id = partition_str;
    131     *persist_storage = false;
    132   }
    133 }
    134 
    135 }  // namespace
    136 
    137 // static
    138 GuestViewBase* WebViewGuest::Create(content::BrowserContext* browser_context,
    139                                     int guest_instance_id) {
    140   return new WebViewGuest(browser_context, guest_instance_id);
    141 }
    142 
    143 // static
    144 bool WebViewGuest::GetGuestPartitionConfigForSite(
    145     const GURL& site,
    146     std::string* partition_domain,
    147     std::string* partition_name,
    148     bool* in_memory) {
    149   if (!site.SchemeIs(content::kGuestScheme))
    150     return false;
    151 
    152   // Since guest URLs are only used for packaged apps, there must be an app
    153   // id in the URL.
    154   CHECK(site.has_host());
    155   *partition_domain = site.host();
    156   // Since persistence is optional, the path must either be empty or the
    157   // literal string.
    158   *in_memory = (site.path() != "/persist");
    159   // The partition name is user supplied value, which we have encoded when the
    160   // URL was created, so it needs to be decoded.
    161   *partition_name =
    162       net::UnescapeURLComponent(site.query(), net::UnescapeRule::NORMAL);
    163   return true;
    164 }
    165 
    166 // static
    167 const char WebViewGuest::Type[] = "webview";
    168 
    169 // static
    170 int WebViewGuest::GetViewInstanceId(WebContents* contents) {
    171   WebViewGuest* guest = FromWebContents(contents);
    172   if (!guest)
    173     return guestview::kInstanceIDNone;
    174 
    175   return guest->view_instance_id();
    176 }
    177 
    178 const char* WebViewGuest::GetAPINamespace() const {
    179   return webview::kAPINamespace;
    180 }
    181 
    182 int WebViewGuest::GetTaskPrefix() const {
    183   return IDS_EXTENSION_TASK_MANAGER_WEBVIEW_TAG_PREFIX;
    184 }
    185 
    186 void WebViewGuest::CreateWebContents(
    187     const std::string& embedder_extension_id,
    188     int embedder_render_process_id,
    189     const GURL& embedder_site_url,
    190     const base::DictionaryValue& create_params,
    191     const WebContentsCreatedCallback& callback) {
    192   content::RenderProcessHost* embedder_render_process_host =
    193       content::RenderProcessHost::FromID(embedder_render_process_id);
    194   std::string storage_partition_id;
    195   bool persist_storage = false;
    196   std::string storage_partition_string;
    197   ParsePartitionParam(create_params, &storage_partition_id, &persist_storage);
    198   // Validate that the partition id coming from the renderer is valid UTF-8,
    199   // since we depend on this in other parts of the code, such as FilePath
    200   // creation. If the validation fails, treat it as a bad message and kill the
    201   // renderer process.
    202   if (!base::IsStringUTF8(storage_partition_id)) {
    203     content::RecordAction(
    204         base::UserMetricsAction("BadMessageTerminate_BPGM"));
    205     base::KillProcess(
    206         embedder_render_process_host->GetHandle(),
    207         content::RESULT_CODE_KILLED_BAD_MESSAGE, false);
    208     callback.Run(NULL);
    209     return;
    210   }
    211   std::string url_encoded_partition = net::EscapeQueryParamValue(
    212       storage_partition_id, false);
    213   // The SiteInstance of a given webview tag is based on the fact that it's
    214   // a guest process in addition to which platform application or which WebUI
    215   // page the tag belongs to and what storage partition is in use, rather than
    216   // the URL that the tag is being navigated to.
    217   std::string partition_domain;
    218   if (embedder_extension_id.empty()) {
    219     DCHECK(content::ChildProcessSecurityPolicy::GetInstance()->HasWebUIBindings(
    220         embedder_render_process_id));
    221     partition_domain = embedder_site_url.host();
    222   } else {
    223     partition_domain = embedder_extension_id;
    224   }
    225   GURL guest_site(base::StringPrintf("%s://%s/%s?%s",
    226                                      content::kGuestScheme,
    227                                      partition_domain.c_str(),
    228                                      persist_storage ? "persist" : "",
    229                                      url_encoded_partition.c_str()));
    230 
    231   // If we already have a webview tag in the same app using the same storage
    232   // partition, we should use the same SiteInstance so the existing tag and
    233   // the new tag can script each other.
    234   GuestViewManager* guest_view_manager =
    235       GuestViewManager::FromBrowserContext(
    236           embedder_render_process_host->GetBrowserContext());
    237   content::SiteInstance* guest_site_instance =
    238       guest_view_manager->GetGuestSiteInstance(guest_site);
    239   if (!guest_site_instance) {
    240     // Create the SiteInstance in a new BrowsingInstance, which will ensure
    241     // that webview tags are also not allowed to send messages across
    242     // different partitions.
    243     guest_site_instance = content::SiteInstance::CreateForURL(
    244         embedder_render_process_host->GetBrowserContext(), guest_site);
    245   }
    246   WebContents::CreateParams params(
    247       embedder_render_process_host->GetBrowserContext(),
    248       guest_site_instance);
    249   params.guest_delegate = this;
    250   callback.Run(WebContents::Create(params));
    251 }
    252 
    253 void WebViewGuest::DidAttachToEmbedder() {
    254   SetUpAutoSize();
    255 
    256   std::string name;
    257   if (attach_params()->GetString(webview::kAttributeName, &name)) {
    258     // If the guest window's name is empty, then the WebView tag's name is
    259     // assigned. Otherwise, the guest window's name takes precedence over the
    260     // WebView tag's name.
    261     if (name_.empty())
    262       name_ = name;
    263   }
    264   ReportFrameNameChange(name_);
    265 
    266   std::string user_agent_override;
    267   if (attach_params()->GetString(webview::kParameterUserAgentOverride,
    268                                  &user_agent_override)) {
    269     SetUserAgentOverride(user_agent_override);
    270   } else {
    271     SetUserAgentOverride("");
    272   }
    273 
    274   std::string src;
    275   if (attach_params()->GetString(webview::kAttributeSrc, &src) && !src.empty())
    276     NavigateGuest(src);
    277 
    278   if (GetOpener()) {
    279     // We need to do a navigation here if the target URL has changed between
    280     // the time the WebContents was created and the time it was attached.
    281     // We also need to do an initial navigation if a RenderView was never
    282     // created for the new window in cases where there is no referrer.
    283     PendingWindowMap::iterator it =
    284         GetOpener()->pending_new_windows_.find(this);
    285     if (it != GetOpener()->pending_new_windows_.end()) {
    286       const NewWindowInfo& new_window_info = it->second;
    287       if (new_window_info.changed || !web_contents()->HasOpener())
    288         NavigateGuest(new_window_info.url.spec());
    289     } else {
    290       NOTREACHED();
    291     }
    292 
    293     // Once a new guest is attached to the DOM of the embedder page, then the
    294     // lifetime of the new guest is no longer managed by the opener guest.
    295     GetOpener()->pending_new_windows_.erase(this);
    296   }
    297 
    298   bool allow_transparency = false;
    299   attach_params()->GetBoolean(webview::kAttributeAllowTransparency,
    300                               &allow_transparency);
    301   // We need to set the background opaque flag after navigation to ensure that
    302   // there is a RenderWidgetHostView available.
    303   SetAllowTransparency(allow_transparency);
    304 
    305   if (web_view_guest_delegate_)
    306     web_view_guest_delegate_->OnDidAttachToEmbedder();
    307 }
    308 
    309 void WebViewGuest::DidInitialize() {
    310   script_executor_.reset(
    311       new ScriptExecutor(web_contents(), &script_observers_));
    312 
    313   notification_registrar_.Add(this,
    314                               content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
    315                               content::Source<WebContents>(web_contents()));
    316 
    317   notification_registrar_.Add(this,
    318                               content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
    319                               content::Source<WebContents>(web_contents()));
    320 
    321   if (web_view_guest_delegate_)
    322     web_view_guest_delegate_->OnDidInitialize();
    323   AttachWebViewHelpers(web_contents());
    324 }
    325 
    326 void WebViewGuest::AttachWebViewHelpers(WebContents* contents) {
    327   if (web_view_guest_delegate_)
    328     web_view_guest_delegate_->OnAttachWebViewHelpers(contents);
    329   web_view_permission_helper_.reset(new WebViewPermissionHelper(this));
    330 }
    331 
    332 void WebViewGuest::DidStopLoading() {
    333   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    334   DispatchEventToEmbedder(
    335       new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
    336 }
    337 
    338 void WebViewGuest::EmbedderDestroyed() {
    339   if (web_view_guest_delegate_)
    340     web_view_guest_delegate_->OnEmbedderDestroyed();
    341 }
    342 
    343 void WebViewGuest::GuestDestroyed() {
    344   // Clean up custom context menu items for this guest.
    345   if (web_view_guest_delegate_)
    346     web_view_guest_delegate_->OnGuestDestroyed();
    347   RemoveWebViewStateFromIOThread(web_contents());
    348 }
    349 
    350 void WebViewGuest::GuestReady() {
    351   // The guest RenderView should always live in an isolated guest process.
    352   CHECK(web_contents()->GetRenderProcessHost()->IsIsolatedGuest());
    353   Send(new ExtensionMsg_SetFrameName(web_contents()->GetRoutingID(), name_));
    354 
    355   // We don't want to accidentally set the opacity of an interstitial page.
    356   // WebContents::GetRenderWidgetHostView will return the RWHV of an
    357   // interstitial page if one is showing at this time. We only want opacity
    358   // to apply to web pages.
    359   web_contents()->GetRenderViewHost()->GetView()->
    360       SetBackgroundOpaque(guest_opaque_);
    361 }
    362 
    363 void WebViewGuest::GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
    364                                                  const gfx::Size& new_size) {
    365   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    366   args->SetInteger(webview::kOldHeight, old_size.height());
    367   args->SetInteger(webview::kOldWidth, old_size.width());
    368   args->SetInteger(webview::kNewHeight, new_size.height());
    369   args->SetInteger(webview::kNewWidth, new_size.width());
    370   DispatchEventToEmbedder(
    371       new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
    372 }
    373 
    374 bool WebViewGuest::IsAutoSizeSupported() const {
    375   return true;
    376 }
    377 
    378 bool WebViewGuest::IsDragAndDropEnabled() const {
    379   return true;
    380 }
    381 
    382 void WebViewGuest::WillDestroy() {
    383   if (!attached() && GetOpener())
    384     GetOpener()->pending_new_windows_.erase(this);
    385   DestroyUnattachedWindows();
    386 
    387   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    388   DispatchEventToEmbedder(
    389       new GuestViewBase::Event(webview::kEventPluginDestroyed, args.Pass()));
    390 }
    391 
    392 bool WebViewGuest::AddMessageToConsole(WebContents* source,
    393                                        int32 level,
    394                                        const base::string16& message,
    395                                        int32 line_no,
    396                                        const base::string16& source_id) {
    397   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    398   // Log levels are from base/logging.h: LogSeverity.
    399   args->SetInteger(webview::kLevel, level);
    400   args->SetString(webview::kMessage, message);
    401   args->SetInteger(webview::kLine, line_no);
    402   args->SetString(webview::kSourceId, source_id);
    403   DispatchEventToEmbedder(
    404       new GuestViewBase::Event(webview::kEventConsoleMessage, args.Pass()));
    405   return true;
    406 }
    407 
    408 void WebViewGuest::CloseContents(WebContents* source) {
    409   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    410   DispatchEventToEmbedder(
    411       new GuestViewBase::Event(webview::kEventClose, args.Pass()));
    412 }
    413 
    414 void WebViewGuest::FindReply(WebContents* source,
    415                              int request_id,
    416                              int number_of_matches,
    417                              const gfx::Rect& selection_rect,
    418                              int active_match_ordinal,
    419                              bool final_update) {
    420   find_helper_.FindReply(request_id,
    421                          number_of_matches,
    422                          selection_rect,
    423                          active_match_ordinal,
    424                          final_update);
    425 }
    426 
    427 bool WebViewGuest::HandleContextMenu(
    428     const content::ContextMenuParams& params) {
    429   if (!web_view_guest_delegate_)
    430     return false;
    431   return web_view_guest_delegate_->HandleContextMenu(params);
    432 }
    433 
    434 void WebViewGuest::HandleKeyboardEvent(
    435     WebContents* source,
    436     const content::NativeWebKeyboardEvent& event) {
    437   if (!attached())
    438     return;
    439 
    440   if (HandleKeyboardShortcuts(event))
    441     return;
    442 
    443   // Send the unhandled keyboard events back to the embedder to reprocess them.
    444   // TODO(fsamuel): This introduces the possibility of out-of-order keyboard
    445   // events because the guest may be arbitrarily delayed when responding to
    446   // keyboard events. In that time, the embedder may have received and processed
    447   // additional key events. This needs to be fixed as soon as possible.
    448   // See http://crbug.com/229882.
    449   embedder_web_contents()->GetDelegate()->HandleKeyboardEvent(
    450       web_contents(), event);
    451 }
    452 
    453 void WebViewGuest::LoadProgressChanged(content::WebContents* source,
    454                                        double progress) {
    455   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    456   args->SetString(guestview::kUrl, web_contents()->GetURL().spec());
    457   args->SetDouble(webview::kProgress, progress);
    458   DispatchEventToEmbedder(
    459       new GuestViewBase::Event(webview::kEventLoadProgress, args.Pass()));
    460 }
    461 
    462 void WebViewGuest::LoadAbort(bool is_top_level,
    463                              const GURL& url,
    464                              const std::string& error_type) {
    465   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    466   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
    467   args->SetString(guestview::kUrl, url.possibly_invalid_spec());
    468   args->SetString(guestview::kReason, error_type);
    469   DispatchEventToEmbedder(
    470       new GuestViewBase::Event(webview::kEventLoadAbort, args.Pass()));
    471 }
    472 
    473 void WebViewGuest::OnFrameNameChanged(bool is_top_level,
    474                                       const std::string& name) {
    475   if (!is_top_level)
    476     return;
    477 
    478   if (name_ == name)
    479     return;
    480 
    481   ReportFrameNameChange(name);
    482 }
    483 
    484 void WebViewGuest::CreateNewGuestWebViewWindow(
    485     const content::OpenURLParams& params) {
    486   GuestViewManager* guest_manager =
    487       GuestViewManager::FromBrowserContext(browser_context());
    488   // Set the attach params to use the same partition as the opener.
    489   // We pull the partition information from the site's URL, which is of the
    490   // form guest://site/{persist}?{partition_name}.
    491   const GURL& site_url = web_contents()->GetSiteInstance()->GetSiteURL();
    492   const std::string storage_partition_id =
    493       GetStoragePartitionIdFromSiteURL(site_url);
    494   base::DictionaryValue create_params;
    495   create_params.SetString(webview::kStoragePartitionId, storage_partition_id);
    496 
    497   guest_manager->CreateGuest(WebViewGuest::Type,
    498                              embedder_extension_id(),
    499                              embedder_web_contents(),
    500                              create_params,
    501                              base::Bind(&WebViewGuest::NewGuestWebViewCallback,
    502                                         base::Unretained(this),
    503                                         params));
    504 }
    505 
    506 void WebViewGuest::NewGuestWebViewCallback(
    507     const content::OpenURLParams& params,
    508     content::WebContents* guest_web_contents) {
    509   WebViewGuest* new_guest = WebViewGuest::FromWebContents(guest_web_contents);
    510   new_guest->SetOpener(this);
    511 
    512   // Take ownership of |new_guest|.
    513   pending_new_windows_.insert(
    514       std::make_pair(new_guest, NewWindowInfo(params.url, std::string())));
    515 
    516   // Request permission to show the new window.
    517   RequestNewWindowPermission(params.disposition,
    518                              gfx::Rect(),
    519                              params.user_gesture,
    520                              new_guest->web_contents());
    521 }
    522 
    523 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
    524 // 'unresponsive' events.
    525 void WebViewGuest::RendererResponsive(content::WebContents* source) {
    526   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    527   args->SetInteger(webview::kProcessId,
    528                    web_contents()->GetRenderProcessHost()->GetID());
    529   DispatchEventToEmbedder(
    530       new GuestViewBase::Event(webview::kEventResponsive, args.Pass()));
    531 }
    532 
    533 void WebViewGuest::RendererUnresponsive(content::WebContents* source) {
    534   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    535   args->SetInteger(webview::kProcessId,
    536                    web_contents()->GetRenderProcessHost()->GetID());
    537   DispatchEventToEmbedder(
    538       new GuestViewBase::Event(webview::kEventUnresponsive, args.Pass()));
    539 }
    540 
    541 void WebViewGuest::Observe(int type,
    542                            const content::NotificationSource& source,
    543                            const content::NotificationDetails& details) {
    544   switch (type) {
    545     case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: {
    546       DCHECK_EQ(content::Source<WebContents>(source).ptr(), web_contents());
    547       if (content::Source<WebContents>(source).ptr() == web_contents())
    548         LoadHandlerCalled();
    549       break;
    550     }
    551     case content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT: {
    552       DCHECK_EQ(content::Source<WebContents>(source).ptr(), web_contents());
    553       content::ResourceRedirectDetails* resource_redirect_details =
    554           content::Details<content::ResourceRedirectDetails>(details).ptr();
    555       bool is_top_level = resource_redirect_details->resource_type ==
    556                           content::RESOURCE_TYPE_MAIN_FRAME;
    557       LoadRedirect(resource_redirect_details->url,
    558                    resource_redirect_details->new_url,
    559                    is_top_level);
    560       break;
    561     }
    562     default:
    563       NOTREACHED() << "Unexpected notification sent.";
    564       break;
    565   }
    566 }
    567 
    568 double WebViewGuest::GetZoom() {
    569   if (!web_view_guest_delegate_)
    570     return 1.0;
    571   return web_view_guest_delegate_->GetZoom();
    572 }
    573 
    574 void WebViewGuest::Find(
    575     const base::string16& search_text,
    576     const blink::WebFindOptions& options,
    577     scoped_refptr<WebViewInternalFindFunction> find_function) {
    578   find_helper_.Find(web_contents(), search_text, options, find_function);
    579 }
    580 
    581 void WebViewGuest::StopFinding(content::StopFindAction action) {
    582   find_helper_.CancelAllFindSessions();
    583   web_contents()->StopFinding(action);
    584 }
    585 
    586 void WebViewGuest::Go(int relative_index) {
    587   web_contents()->GetController().GoToOffset(relative_index);
    588 }
    589 
    590 void WebViewGuest::Reload() {
    591   // TODO(fsamuel): Don't check for repost because we don't want to show
    592   // Chromium's repost warning. We might want to implement a separate API
    593   // for registering a callback if a repost is about to happen.
    594   web_contents()->GetController().Reload(false);
    595 }
    596 
    597 void WebViewGuest::SetUserAgentOverride(
    598     const std::string& user_agent_override) {
    599   if (!attached())
    600     return;
    601   is_overriding_user_agent_ = !user_agent_override.empty();
    602   if (is_overriding_user_agent_) {
    603     content::RecordAction(UserMetricsAction("WebView.Guest.OverrideUA"));
    604   }
    605   web_contents()->SetUserAgentOverride(user_agent_override);
    606 }
    607 
    608 void WebViewGuest::Stop() {
    609   web_contents()->Stop();
    610 }
    611 
    612 void WebViewGuest::Terminate() {
    613   content::RecordAction(UserMetricsAction("WebView.Guest.Terminate"));
    614   base::ProcessHandle process_handle =
    615       web_contents()->GetRenderProcessHost()->GetHandle();
    616   if (process_handle)
    617     base::KillProcess(process_handle, content::RESULT_CODE_KILLED, false);
    618 }
    619 
    620 bool WebViewGuest::ClearData(const base::Time remove_since,
    621                              uint32 removal_mask,
    622                              const base::Closure& callback) {
    623   content::RecordAction(UserMetricsAction("WebView.Guest.ClearData"));
    624   content::StoragePartition* partition =
    625       content::BrowserContext::GetStoragePartition(
    626           web_contents()->GetBrowserContext(),
    627           web_contents()->GetSiteInstance());
    628 
    629   if (!partition)
    630     return false;
    631 
    632   partition->ClearData(
    633       removal_mask,
    634       content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
    635       GURL(),
    636       content::StoragePartition::OriginMatcherFunction(),
    637       remove_since,
    638       base::Time::Now(),
    639       callback);
    640   return true;
    641 }
    642 
    643 WebViewGuest::WebViewGuest(content::BrowserContext* browser_context,
    644                            int guest_instance_id)
    645     : GuestView<WebViewGuest>(browser_context, guest_instance_id),
    646       find_helper_(this),
    647       is_overriding_user_agent_(false),
    648       guest_opaque_(true),
    649       javascript_dialog_helper_(this) {
    650   web_view_guest_delegate_.reset(
    651       ExtensionsAPIClient::Get()->CreateWebViewGuestDelegate(this));
    652 }
    653 
    654 WebViewGuest::~WebViewGuest() {
    655 }
    656 
    657 void WebViewGuest::DidCommitProvisionalLoadForFrame(
    658     content::RenderFrameHost* render_frame_host,
    659     const GURL& url,
    660     ui::PageTransition transition_type) {
    661   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    662   args->SetString(guestview::kUrl, url.spec());
    663   args->SetBoolean(guestview::kIsTopLevel, !render_frame_host->GetParent());
    664   args->SetString(webview::kInternalBaseURLForDataURL,
    665                   web_contents()
    666                       ->GetController()
    667                       .GetLastCommittedEntry()
    668                       ->GetBaseURLForDataURL()
    669                       .spec());
    670   args->SetInteger(webview::kInternalCurrentEntryIndex,
    671                    web_contents()->GetController().GetCurrentEntryIndex());
    672   args->SetInteger(webview::kInternalEntryCount,
    673                    web_contents()->GetController().GetEntryCount());
    674   args->SetInteger(webview::kInternalProcessId,
    675                    web_contents()->GetRenderProcessHost()->GetID());
    676   DispatchEventToEmbedder(
    677       new GuestViewBase::Event(webview::kEventLoadCommit, args.Pass()));
    678 
    679   find_helper_.CancelAllFindSessions();
    680   if (web_view_guest_delegate_) {
    681     web_view_guest_delegate_->OnDidCommitProvisionalLoadForFrame(
    682         !render_frame_host->GetParent());
    683   }
    684 }
    685 
    686 void WebViewGuest::DidFailProvisionalLoad(
    687     content::RenderFrameHost* render_frame_host,
    688     const GURL& validated_url,
    689     int error_code,
    690     const base::string16& error_description) {
    691   LoadAbort(!render_frame_host->GetParent(), validated_url,
    692             net::ErrorToShortString(error_code));
    693 }
    694 
    695 void WebViewGuest::DidStartProvisionalLoadForFrame(
    696     content::RenderFrameHost* render_frame_host,
    697     const GURL& validated_url,
    698     bool is_error_page,
    699     bool is_iframe_srcdoc) {
    700   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    701   args->SetString(guestview::kUrl, validated_url.spec());
    702   args->SetBoolean(guestview::kIsTopLevel, !render_frame_host->GetParent());
    703   DispatchEventToEmbedder(
    704       new GuestViewBase::Event(webview::kEventLoadStart, args.Pass()));
    705 }
    706 
    707 void WebViewGuest::DocumentLoadedInFrame(
    708     content::RenderFrameHost* render_frame_host) {
    709   if (web_view_guest_delegate_)
    710     web_view_guest_delegate_->OnDocumentLoadedInFrame(render_frame_host);
    711 }
    712 
    713 bool WebViewGuest::OnMessageReceived(const IPC::Message& message,
    714                                      RenderFrameHost* render_frame_host) {
    715   bool handled = true;
    716   IPC_BEGIN_MESSAGE_MAP(WebViewGuest, message)
    717     IPC_MESSAGE_HANDLER(ExtensionHostMsg_FrameNameChanged, OnFrameNameChanged)
    718     IPC_MESSAGE_UNHANDLED(handled = false)
    719   IPC_END_MESSAGE_MAP()
    720   return handled;
    721 }
    722 
    723 void WebViewGuest::RenderProcessGone(base::TerminationStatus status) {
    724   // Cancel all find sessions in progress.
    725   find_helper_.CancelAllFindSessions();
    726 
    727   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    728   args->SetInteger(webview::kProcessId,
    729                    web_contents()->GetRenderProcessHost()->GetID());
    730   args->SetString(webview::kReason, TerminationStatusToString(status));
    731   DispatchEventToEmbedder(
    732       new GuestViewBase::Event(webview::kEventExit, args.Pass()));
    733 }
    734 
    735 void WebViewGuest::UserAgentOverrideSet(const std::string& user_agent) {
    736   if (!attached())
    737     return;
    738   content::NavigationController& controller = web_contents()->GetController();
    739   content::NavigationEntry* entry = controller.GetVisibleEntry();
    740   if (!entry)
    741     return;
    742   entry->SetIsOverridingUserAgent(!user_agent.empty());
    743   web_contents()->GetController().Reload(false);
    744 }
    745 
    746 void WebViewGuest::ReportFrameNameChange(const std::string& name) {
    747   name_ = name;
    748   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    749   args->SetString(webview::kName, name);
    750   DispatchEventToEmbedder(
    751       new GuestViewBase::Event(webview::kEventFrameNameChanged, args.Pass()));
    752 }
    753 
    754 void WebViewGuest::LoadHandlerCalled() {
    755   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    756   DispatchEventToEmbedder(
    757       new GuestViewBase::Event(webview::kEventContentLoad, args.Pass()));
    758 }
    759 
    760 void WebViewGuest::LoadRedirect(const GURL& old_url,
    761                                 const GURL& new_url,
    762                                 bool is_top_level) {
    763   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
    764   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
    765   args->SetString(webview::kNewURL, new_url.spec());
    766   args->SetString(webview::kOldURL, old_url.spec());
    767   DispatchEventToEmbedder(
    768       new GuestViewBase::Event(webview::kEventLoadRedirect, args.Pass()));
    769 }
    770 
    771 void WebViewGuest::PushWebViewStateToIOThread() {
    772   const GURL& site_url = web_contents()->GetSiteInstance()->GetSiteURL();
    773   std::string partition_domain;
    774   std::string partition_id;
    775   bool in_memory;
    776   if (!GetGuestPartitionConfigForSite(
    777           site_url, &partition_domain, &partition_id, &in_memory)) {
    778     NOTREACHED();
    779     return;
    780   }
    781 
    782   WebViewRendererState::WebViewInfo web_view_info;
    783   web_view_info.embedder_process_id = embedder_render_process_id();
    784   web_view_info.instance_id = view_instance_id();
    785   web_view_info.partition_id = partition_id;
    786   web_view_info.embedder_extension_id = embedder_extension_id();
    787 
    788   content::BrowserThread::PostTask(
    789       content::BrowserThread::IO,
    790       FROM_HERE,
    791       base::Bind(&WebViewRendererState::AddGuest,
    792                  base::Unretained(WebViewRendererState::GetInstance()),
    793                  web_contents()->GetRenderProcessHost()->GetID(),
    794                  web_contents()->GetRoutingID(),
    795                  web_view_info));
    796 }
    797 
    798 // static
    799 void WebViewGuest::RemoveWebViewStateFromIOThread(
    800     WebContents* web_contents) {
    801   content::BrowserThread::PostTask(
    802       content::BrowserThread::IO, FROM_HERE,
    803       base::Bind(
    804           &WebViewRendererState::RemoveGuest,
    805           base::Unretained(WebViewRendererState::GetInstance()),
    806           web_contents->GetRenderProcessHost()->GetID(),
    807           web_contents->GetRoutingID()));
    808 }
    809 
    810 content::WebContents* WebViewGuest::CreateNewGuestWindow(
    811     const content::WebContents::CreateParams& create_params) {
    812   GuestViewManager* guest_manager =
    813       GuestViewManager::FromBrowserContext(browser_context());
    814   return guest_manager->CreateGuestWithWebContentsParams(
    815       WebViewGuest::Type,
    816       embedder_extension_id(),
    817       embedder_web_contents()->GetRenderProcessHost()->GetID(),
    818       create_params);
    819 }
    820 
    821 void WebViewGuest::RequestMediaAccessPermission(
    822     content::WebContents* source,
    823     const content::MediaStreamRequest& request,
    824     const content::MediaResponseCallback& callback) {
    825   web_view_permission_helper_->RequestMediaAccessPermission(source,
    826                                                             request,
    827                                                             callback);
    828 }
    829 
    830 bool WebViewGuest::CheckMediaAccessPermission(content::WebContents* source,
    831                                               const GURL& security_origin,
    832                                               content::MediaStreamType type) {
    833   return web_view_permission_helper_->CheckMediaAccessPermission(
    834       source, security_origin, type);
    835 }
    836 
    837 void WebViewGuest::CanDownload(
    838     content::RenderViewHost* render_view_host,
    839     const GURL& url,
    840     const std::string& request_method,
    841     const base::Callback<void(bool)>& callback) {
    842   web_view_permission_helper_->CanDownload(render_view_host,
    843                                            url,
    844                                            request_method,
    845                                            callback);
    846 }
    847 
    848 void WebViewGuest::RequestPointerLockPermission(
    849     bool user_gesture,
    850     bool last_unlocked_by_target,
    851     const base::Callback<void(bool)>& callback) {
    852   web_view_permission_helper_->RequestPointerLockPermission(
    853       user_gesture,
    854       last_unlocked_by_target,
    855       callback);
    856 }
    857 
    858 void WebViewGuest::WillAttachToEmbedder() {
    859   // We must install the mapping from guests to WebViews prior to resuming
    860   // suspended resource loads so that the WebRequest API will catch resource
    861   // requests.
    862   PushWebViewStateToIOThread();
    863 }
    864 
    865 content::JavaScriptDialogManager*
    866     WebViewGuest::GetJavaScriptDialogManager() {
    867   return &javascript_dialog_helper_;
    868 }
    869 
    870 content::ColorChooser* WebViewGuest::OpenColorChooser(
    871     WebContents* web_contents,
    872     SkColor color,
    873     const std::vector<content::ColorSuggestion>& suggestions) {
    874   if (!attached() || !embedder_web_contents()->GetDelegate())
    875     return NULL;
    876   return embedder_web_contents()->GetDelegate()->OpenColorChooser(
    877       web_contents, color, suggestions);
    878 }
    879 
    880 void WebViewGuest::NavigateGuest(const std::string& src) {
    881   if (!attached())
    882     return;
    883 
    884   GURL url = ResolveURL(src);
    885 
    886   // Do not allow navigating a guest to schemes other than known safe schemes.
    887   // This will block the embedder trying to load unwanted schemes, e.g.
    888   // chrome://settings.
    889   bool scheme_is_blocked =
    890       (!content::ChildProcessSecurityPolicy::GetInstance()->IsWebSafeScheme(
    891            url.scheme()) &&
    892        !url.SchemeIs(url::kAboutScheme)) ||
    893       url.SchemeIs(url::kJavaScriptScheme);
    894   if (scheme_is_blocked || !url.is_valid()) {
    895     LoadAbort(true /* is_top_level */, url,
    896               net::ErrorToShortString(net::ERR_ABORTED));
    897     return;
    898   }
    899 
    900   GURL validated_url(url);
    901   web_contents()->GetRenderProcessHost()->FilterURL(false, &validated_url);
    902   // As guests do not swap processes on navigation, only navigations to
    903   // normal web URLs are supported.  No protocol handlers are installed for
    904   // other schemes (e.g., WebUI or extensions), and no permissions or bindings
    905   // can be granted to the guest process.
    906   LoadURLWithParams(validated_url,
    907                     content::Referrer(),
    908                     ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
    909                     web_contents());
    910 }
    911 
    912 bool WebViewGuest::HandleKeyboardShortcuts(
    913     const content::NativeWebKeyboardEvent& event) {
    914   if (event.type != blink::WebInputEvent::RawKeyDown)
    915     return false;
    916 
    917   // If the user hits the escape key without any modifiers then unlock the
    918   // mouse if necessary.
    919   if ((event.windowsKeyCode == ui::VKEY_ESCAPE) &&
    920       !(event.modifiers & blink::WebInputEvent::InputModifiers)) {
    921     return web_contents()->GotResponseToLockMouseRequest(false);
    922   }
    923 
    924 #if defined(OS_MACOSX)
    925   if (event.modifiers != blink::WebInputEvent::MetaKey)
    926     return false;
    927 
    928   if (event.windowsKeyCode == ui::VKEY_OEM_4) {
    929     Go(-1);
    930     return true;
    931   }
    932 
    933   if (event.windowsKeyCode == ui::VKEY_OEM_6) {
    934     Go(1);
    935     return true;
    936   }
    937 #else
    938   if (event.windowsKeyCode == ui::VKEY_BROWSER_BACK) {
    939     Go(-1);
    940     return true;
    941   }
    942 
    943   if (event.windowsKeyCode == ui::VKEY_BROWSER_FORWARD) {
    944     Go(1);
    945     return true;
    946   }
    947 #endif
    948 
    949   return false;
    950 }
    951 
    952 void WebViewGuest::SetUpAutoSize() {
    953   // Read the autosize parameters passed in from the embedder.
    954   bool auto_size_enabled = false;
    955   attach_params()->GetBoolean(webview::kAttributeAutoSize, &auto_size_enabled);
    956 
    957   int max_height = 0;
    958   int max_width = 0;
    959   attach_params()->GetInteger(webview::kAttributeMaxHeight, &max_height);
    960   attach_params()->GetInteger(webview::kAttributeMaxWidth, &max_width);
    961 
    962   int min_height = 0;
    963   int min_width = 0;
    964   attach_params()->GetInteger(webview::kAttributeMinHeight, &min_height);
    965   attach_params()->GetInteger(webview::kAttributeMinWidth, &min_width);
    966 
    967   // Call SetAutoSize to apply all the appropriate validation and clipping of
    968   // values.
    969   SetAutoSize(auto_size_enabled,
    970               gfx::Size(min_width, min_height),
    971               gfx::Size(max_width, max_height));
    972 }
    973 
    974 void WebViewGuest::ShowContextMenu(
    975     int request_id,
    976     const WebViewGuestDelegate::MenuItemVector* items) {
    977   if (web_view_guest_delegate_)
    978     web_view_guest_delegate_->OnShowContextMenu(request_id, items);
    979 }
    980 
    981 void WebViewGuest::SetName(const std::string& name) {
    982   if (name_ == name)
    983     return;
    984   name_ = name;
    985 
    986   Send(new ExtensionMsg_SetFrameName(routing_id(), name_));
    987 }
    988 
    989 void WebViewGuest::SetZoom(double zoom_factor) {
    990   if (web_view_guest_delegate_)
    991     web_view_guest_delegate_->OnSetZoom(zoom_factor);
    992 }
    993 
    994 void WebViewGuest::SetAllowTransparency(bool allow) {
    995   if (guest_opaque_ != allow)
    996     return;
    997 
    998   guest_opaque_ = !allow;
    999   if (!web_contents()->GetRenderViewHost()->GetView())
   1000     return;
   1001 
   1002   web_contents()->GetRenderViewHost()->GetView()->SetBackgroundOpaque(!allow);
   1003 }
   1004 
   1005 void WebViewGuest::AddNewContents(content::WebContents* source,
   1006                                   content::WebContents* new_contents,
   1007                                   WindowOpenDisposition disposition,
   1008                                   const gfx::Rect& initial_pos,
   1009                                   bool user_gesture,
   1010                                   bool* was_blocked) {
   1011   if (was_blocked)
   1012     *was_blocked = false;
   1013   RequestNewWindowPermission(disposition,
   1014                              initial_pos,
   1015                              user_gesture,
   1016                              new_contents);
   1017 }
   1018 
   1019 content::WebContents* WebViewGuest::OpenURLFromTab(
   1020     content::WebContents* source,
   1021     const content::OpenURLParams& params) {
   1022   // If the guest wishes to navigate away prior to attachment then we save the
   1023   // navigation to perform upon attachment. Navigation initializes a lot of
   1024   // state that assumes an embedder exists, such as RenderWidgetHostViewGuest.
   1025   // Navigation also resumes resource loading which we don't want to allow
   1026   // until attachment.
   1027   if (!attached()) {
   1028     WebViewGuest* opener = GetOpener();
   1029     PendingWindowMap::iterator it =
   1030         opener->pending_new_windows_.find(this);
   1031     if (it == opener->pending_new_windows_.end())
   1032       return NULL;
   1033     const NewWindowInfo& info = it->second;
   1034     NewWindowInfo new_window_info(params.url, info.name);
   1035     new_window_info.changed = new_window_info.url != info.url;
   1036     it->second = new_window_info;
   1037     return NULL;
   1038   }
   1039   if (params.disposition == CURRENT_TAB) {
   1040     // This can happen for cross-site redirects.
   1041     LoadURLWithParams(params.url, params.referrer, params.transition, source);
   1042     return source;
   1043   }
   1044 
   1045   CreateNewGuestWebViewWindow(params);
   1046   return NULL;
   1047 }
   1048 
   1049 void WebViewGuest::WebContentsCreated(WebContents* source_contents,
   1050                                       int opener_render_frame_id,
   1051                                       const base::string16& frame_name,
   1052                                       const GURL& target_url,
   1053                                       content::WebContents* new_contents) {
   1054   WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents);
   1055   CHECK(guest);
   1056   guest->SetOpener(this);
   1057   std::string guest_name = base::UTF16ToUTF8(frame_name);
   1058   guest->name_ = guest_name;
   1059   pending_new_windows_.insert(
   1060       std::make_pair(guest, NewWindowInfo(target_url, guest_name)));
   1061 }
   1062 
   1063 void WebViewGuest::LoadURLWithParams(const GURL& url,
   1064                                      const content::Referrer& referrer,
   1065                                      ui::PageTransition transition_type,
   1066                                      content::WebContents* web_contents) {
   1067   content::NavigationController::LoadURLParams load_url_params(url);
   1068   load_url_params.referrer = referrer;
   1069   load_url_params.transition_type = transition_type;
   1070   load_url_params.extra_headers = std::string();
   1071   if (is_overriding_user_agent_) {
   1072     load_url_params.override_user_agent =
   1073         content::NavigationController::UA_OVERRIDE_TRUE;
   1074   }
   1075   web_contents->GetController().LoadURLWithParams(load_url_params);
   1076 }
   1077 
   1078 void WebViewGuest::RequestNewWindowPermission(
   1079     WindowOpenDisposition disposition,
   1080     const gfx::Rect& initial_bounds,
   1081     bool user_gesture,
   1082     content::WebContents* new_contents) {
   1083   WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents);
   1084   if (!guest)
   1085     return;
   1086   PendingWindowMap::iterator it = pending_new_windows_.find(guest);
   1087   if (it == pending_new_windows_.end())
   1088     return;
   1089   const NewWindowInfo& new_window_info = it->second;
   1090 
   1091   // Retrieve the opener partition info if we have it.
   1092   const GURL& site_url = new_contents->GetSiteInstance()->GetSiteURL();
   1093   std::string storage_partition_id = GetStoragePartitionIdFromSiteURL(site_url);
   1094 
   1095   base::DictionaryValue request_info;
   1096   request_info.SetInteger(webview::kInitialHeight, initial_bounds.height());
   1097   request_info.SetInteger(webview::kInitialWidth, initial_bounds.width());
   1098   request_info.Set(webview::kTargetURL,
   1099                    new base::StringValue(new_window_info.url.spec()));
   1100   request_info.Set(webview::kName, new base::StringValue(new_window_info.name));
   1101   request_info.SetInteger(webview::kWindowID, guest->guest_instance_id());
   1102   // We pass in partition info so that window-s created through newwindow
   1103   // API can use it to set their partition attribute.
   1104   request_info.Set(webview::kStoragePartitionId,
   1105                    new base::StringValue(storage_partition_id));
   1106   request_info.Set(
   1107       webview::kWindowOpenDisposition,
   1108       new base::StringValue(WindowOpenDispositionToString(disposition)));
   1109 
   1110   web_view_permission_helper_->
   1111       RequestPermission(WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW,
   1112                         request_info,
   1113                         base::Bind(&WebViewGuest::OnWebViewNewWindowResponse,
   1114                                    base::Unretained(this),
   1115                                    guest->guest_instance_id()),
   1116                                    false /* allowed_by_default */);
   1117 }
   1118 
   1119 void WebViewGuest::DestroyUnattachedWindows() {
   1120   // Destroy() reaches in and removes the WebViewGuest from its opener's
   1121   // pending_new_windows_ set. To avoid mutating the set while iterating, we
   1122   // create a copy of the pending new windows set and iterate over the copy.
   1123   PendingWindowMap pending_new_windows(pending_new_windows_);
   1124   // Clean up unattached new windows opened by this guest.
   1125   for (PendingWindowMap::const_iterator it = pending_new_windows.begin();
   1126        it != pending_new_windows.end(); ++it) {
   1127     it->first->Destroy();
   1128   }
   1129   // All pending windows should be removed from the set after Destroy() is
   1130   // called on all of them.
   1131   DCHECK(pending_new_windows_.empty());
   1132 }
   1133 
   1134 GURL WebViewGuest::ResolveURL(const std::string& src) {
   1135   if (!in_extension()) {
   1136     return GURL(src);
   1137   }
   1138 
   1139   GURL default_url(base::StringPrintf("%s://%s/",
   1140                                       kExtensionScheme,
   1141                                       embedder_extension_id().c_str()));
   1142   return default_url.Resolve(src);
   1143 }
   1144 
   1145 void WebViewGuest::OnWebViewNewWindowResponse(
   1146     int new_window_instance_id,
   1147     bool allow,
   1148     const std::string& user_input) {
   1149   WebViewGuest* guest =
   1150       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
   1151   if (!guest)
   1152     return;
   1153 
   1154   if (!allow)
   1155     guest->Destroy();
   1156 }
   1157 
   1158 }  // namespace extensions
   1159