GuestView: Move GuestViewManager extension dependencies to ExtensionsGuestViewManagerDelegate

extensions/browser/guest_view/web_view/web_view_guest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "extensions/browser/guest_view/web_view/web_view_guest.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 266 matching lines @@
   std::string partition_domain = GetOwnerSiteURL().host();
   GURL guest_site(base::StringPrintf("%s://%s/%s?%s",
                                      content::kGuestScheme,
                                      partition_domain.c_str(),
                                      persist_storage ? "persist" : "",
                                      url_encoded_partition.c_str()));
 
   // If we already have a webview tag in the same app using the same storage
   // partition, we should use the same SiteInstance so the existing tag and
   // the new tag can script each other.
-  auto guest_view_manager = GuestViewManager::FromBrowserContextIfAvailable(
+  auto guest_view_manager = GuestViewManager::FromBrowserContext(
       owner_render_process_host->GetBrowserContext());
   content::SiteInstance* guest_site_instance =
       guest_view_manager->GetGuestSiteInstance(guest_site);
   if (!guest_site_instance) {
     // Create the SiteInstance in a new BrowsingInstance, which will ensure
     // that webview tags are also not allowed to send messages across
     // different partitions.
     guest_site_instance = content::SiteInstance::CreateForURL(
         owner_render_process_host->GetBrowserContext(), guest_site);
   }
@@ skipping 90 matching lines @@
   WebViewKey key(owner_web_contents()->GetRenderProcessHost()->GetID(),
                  view_instance_id());
   web_view_key_to_id_map.Get().erase(key);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &RemoveWebViewEventListenersOnIOThread,
           browser_context(),
-          owner_extension_id(),
+          owner_host(),
           owner_web_contents()->GetRenderProcessHost()->GetID(),
           view_instance_id()));
 }
 
 const char* WebViewGuest::GetAPINamespace() const {
   return webview::kAPINamespace;
 }
 
 int WebViewGuest::GetTaskPrefix() const {
   return IDS_EXTENSION_TASK_MANAGER_WEBVIEW_TAG_PREFIX;
@@ skipping 146 matching lines @@
   args->SetString(guestview::kUrl, url.possibly_invalid_spec());
   args->SetInteger(guestview::kCode, error_code);
   args->SetString(guestview::kReason, error_type);
   DispatchEventToView(
       new GuestViewEvent(webview::kEventLoadAbort, args.Pass()));
 }
 
 void WebViewGuest::CreateNewGuestWebViewWindow(
     const content::OpenURLParams& params) {
   GuestViewManager* guest_manager =
-      GuestViewManager::FromBrowserContextIfAvailable(browser_context());
+      GuestViewManager::FromBrowserContext(browser_context());
   // Set the attach params to use the same partition as the opener.
   // We pull the partition information from the site's URL, which is of the
   // form guest://site/{persist}?{partition_name}.
   const GURL& site_url = web_contents()->GetSiteInstance()->GetSiteURL();
   const std::string storage_partition_id =
       GetStoragePartitionIdFromSiteURL(site_url);
   base::DictionaryValue create_params;
   create_params.SetString(webview::kStoragePartitionId, storage_partition_id);
 
   guest_manager->CreateGuest(WebViewGuest::Type,
@@ skipping 288 matching lines @@
           site_url, &partition_domain, &partition_id, &in_memory)) {
     NOTREACHED();
     return;
   }
 
   WebViewRendererState::WebViewInfo web_view_info;
   web_view_info.embedder_process_id =
       owner_web_contents()->GetRenderProcessHost()->GetID();
   web_view_info.instance_id = view_instance_id();
   web_view_info.partition_id = partition_id;
-  web_view_info.owner_extension_id = owner_extension_id();
+  web_view_info.owner_extension_id = owner_host();
   web_view_info.rules_registry_id = rules_registry_id_;
 
   // Get content scripts IDs added by the guest.
   WebViewContentScriptManager* manager =
       WebViewContentScriptManager::Get(browser_context());
   DCHECK(manager);
   web_view_info.content_script_ids = manager->GetContentScriptIDSet(
       web_view_info.embedder_process_id, web_view_info.instance_id);
 
   content::BrowserThread::PostTask(
@@ skipping 79 matching lines @@
   GURL url = ResolveURL(src);
 
   LoadURLWithParams(url, content::Referrer(),
                     ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                     force_navigation);
 }
 
 bool WebViewGuest::HandleKeyboardShortcuts(
     const content::NativeWebKeyboardEvent& event) {
   // <webview> outside of Chrome Apps do not handle keyboard shortcuts.
-  if (!in_extension())
-    return false;
+  if (!GuestViewManager::FromBrowserContext(browser_context())->
+          IsOwnedByExtension(this)) {
+  return false;
+ }

[lazyboy, 2015/04/22 15:16:29]

indent

[Fady Samuel, 2015/04/22 23:09:48]

Done.

 
   if (event.type != blink::WebInputEvent::RawKeyDown)
     return false;
 
   // If the user hits the escape key without any modifiers then unlock the
   // mouse if necessary.
   if ((event.windowsKeyCode == ui::VKEY_ESCAPE) &&
       !(event.modifiers & blink::WebInputEvent::InputModifiers)) {
     return web_contents()->GotResponseToLockMouseRequest(false);
   }
@@ skipping 367 matching lines @@
   web_view_permission_helper_->
       RequestPermission(WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW,
                         request_info,
                         base::Bind(&WebViewGuest::OnWebViewNewWindowResponse,
                                    weak_ptr_factory_.GetWeakPtr(),
                                    guest->guest_instance_id()),
                                    false /* allowed_by_default */);
 }
 
 GURL WebViewGuest::ResolveURL(const std::string& src) {
-  if (!in_extension())
+  if (!GuestViewManager::FromBrowserContext(browser_context())->
+          IsOwnedByExtension(this)) {
     return GURL(src);
+  }
 
   GURL default_url(base::StringPrintf("%s://%s/",
                                       kExtensionScheme,
-                                      owner_extension_id().c_str()));
+                                      owner_host().c_str()));
   return default_url.Resolve(src);
 }
 
 void WebViewGuest::OnWebViewNewWindowResponse(
     int new_window_instance_id,
     bool allow,
     const std::string& user_input) {
   auto guest =
       WebViewGuest::From(owner_web_contents()->GetRenderProcessHost()->GetID(),
                          new_window_instance_id);
@@ skipping 30 matching lines @@
     scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
     DispatchEventToView(
         new GuestViewEvent(webview::kEventExitFullscreen, args.Pass()));
   }
   // Since we changed fullscreen state, sending a Resize message ensures that
   // renderer/ sees the change.
   web_contents()->GetRenderViewHost()->WasResized();
 }
 
 }  // namespace extensions