Remove GuestWebContentsCreated

chrome/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 "chrome/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 "chrome/browser/chrome_notification_types.h"
@@ skipping 163 matching lines @@
 #if defined(ENABLE_FULL_PRINTING)
   printing::PrintViewManager::CreateForWebContents(contents);
   printing::PrintPreviewMessageHandler::CreateForWebContents(contents);
 #else
   printing::PrintViewManagerBasic::CreateForWebContents(contents);
 #endif  // defined(ENABLE_FULL_PRINTING)
 #endif  // defined(ENABLE_PRINTING)
   PDFTabHelper::CreateForWebContents(contents);
 }
 
+void ParsePartitionParam(const base::DictionaryValue& create_params,
+                         std::string* storage_partition_id,
+                         bool* persist_storage) {
+  std::string partition_str;
+  if (!create_params.GetString(webview::kStoragePartitionId, &partition_str)) {
+    return;
+  }
+
+  // Since the "persist:" prefix is in ASCII, StartsWith will work fine on
+  // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely
+  // remove the prefix without splicing in the middle of a multi-byte codepoint.
+  // We can use the rest of the string as UTF-8 encoded one.
+  if (StartsWithASCII(partition_str, "persist:", true)) {
+    size_t index = partition_str.find(":");
+    CHECK(index != std::string::npos);
+    // It is safe to do index + 1, since we tested for the full prefix above.
+    *storage_partition_id = partition_str.substr(index + 1);
+
+    if (storage_partition_id->empty()) {
+      // TODO(lazyboy): Better way to deal with this error.
+      return;
+    }
+    *persist_storage = true;
+  } else {
+    *storage_partition_id = partition_str;
+    *persist_storage = false;
+  }
+}
+
 }  // namespace
 
-WebViewGuest::WebViewGuest(int guest_instance_id,
-                           WebContents* guest_web_contents,
-                           const std::string& embedder_extension_id)
-    : GuestView<WebViewGuest>(guest_instance_id),
-      script_executor_(new extensions::ScriptExecutor(guest_web_contents,
-                                                      &script_observers_)),
+WebViewGuest::WebViewGuest(int guest_instance_id)
+   :  GuestView<WebViewGuest>(guest_instance_id),
       pending_context_menu_request_id_(0),
       next_permission_request_id_(0),
       is_overriding_user_agent_(false),
       main_frame_id_(0),
       chromevox_injected_(false),
       find_helper_(this),
       javascript_dialog_helper_(this) {
-  Init(guest_web_contents, embedder_extension_id);
-  notification_registrar_.Add(
-      this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
-      content::Source<WebContents>(guest_web_contents));
-
-  notification_registrar_.Add(
-      this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
-      content::Source<WebContents>(guest_web_contents));
-
-#if defined(OS_CHROMEOS)
-  chromeos::AccessibilityManager* accessibility_manager =
-      chromeos::AccessibilityManager::Get();
-  CHECK(accessibility_manager);
-  accessibility_subscription_ = accessibility_manager->RegisterCallback(
-      base::Bind(&WebViewGuest::OnAccessibilityStatusChanged,
-                 base::Unretained(this)));
-#endif
-
-  AttachWebViewHelpers(guest_web_contents);
 }
 
 // static
 bool WebViewGuest::GetGuestPartitionConfigForSite(
     const GURL& site,
     std::string* partition_domain,
     std::string* partition_name,
     bool* in_memory) {
   if (!site.SchemeIs(content::kGuestScheme))
     return false;
@@ skipping 18 matching lines @@
 // static
 int WebViewGuest::GetViewInstanceId(WebContents* contents) {
   WebViewGuest* guest = FromWebContents(contents);
   if (!guest)
     return guestview::kInstanceIDNone;
 
   return guest->view_instance_id();
 }
 
 // static
-void WebViewGuest::ParsePartitionParam(
-    const base::DictionaryValue* extra_params,
-    std::string* storage_partition_id,
-    bool* persist_storage) {
-  std::string partition_str;
-  if (!extra_params->GetString(webview::kStoragePartitionId, &partition_str)) {
-    return;
-  }
-
-  // Since the "persist:" prefix is in ASCII, StartsWith will work fine on
-  // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely
-  // remove the prefix without splicing in the middle of a multi-byte codepoint.
-  // We can use the rest of the string as UTF-8 encoded one.
-  if (StartsWithASCII(partition_str, "persist:", true)) {
-    size_t index = partition_str.find(":");
-    CHECK(index != std::string::npos);
-    // It is safe to do index + 1, since we tested for the full prefix above.
-    *storage_partition_id = partition_str.substr(index + 1);
-
-    if (storage_partition_id->empty()) {
-      // TODO(lazyboy): Better way to deal with this error.
-      return;
-    }
-    *persist_storage = true;
-  } else {
-    *storage_partition_id = partition_str;
-    *persist_storage = false;
-  }
-}
-
-// static
 void WebViewGuest::RecordUserInitiatedUMA(const PermissionResponseInfo& info,
                                           bool allow) {
   if (allow) {
     // Note that |allow| == true means the embedder explicitly allowed the
     // request. For some requests they might still fail. An example of such
     // scenario would be: an embedder allows geolocation request but doesn't
     // have geolocation access on its own.
     switch (info.permission_type) {
       case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD:
         content::RecordAction(
@@ skipping 78 matching lines @@
     // TODO(lazyboy): We need to expose some kind of enum equivalent of
     // |command_id| instead of plain integers.
     item_value->SetInteger(webview::kMenuItemCommandId,
                            menu_model.GetCommandIdAt(i));
     item_value->SetString(webview::kMenuItemLabel, menu_model.GetLabelAt(i));
     items->Append(item_value);
   }
   return items.Pass();
 }
 
+void WebViewGuest::CreateWebContents(
+    const std::string& embedder_extension_id,
+    int embedder_render_process_id,
+    const base::DictionaryValue& create_params,
+    const WebContentsCreatedCallback& callback) {
+  content::RenderProcessHost* embedder_render_process_host =
+      content::RenderProcessHost::FromID(embedder_render_process_id);
+  std::string storage_partition_id;
+  bool persist_storage = false;
+  std::string storage_partition_string;
+  ParsePartitionParam(create_params, &storage_partition_id, &persist_storage);
+  // Validate that the partition id coming from the renderer is valid UTF-8,
+  // since we depend on this in other parts of the code, such as FilePath
+  // creation. If the validation fails, treat it as a bad message and kill the
+  // renderer process.
+  if (!base::IsStringUTF8(storage_partition_id)) {
+    content::RecordAction(
+        base::UserMetricsAction("BadMessageTerminate_BPGM"));
+    base::KillProcess(
+        embedder_render_process_host->GetHandle(),
+        content::RESULT_CODE_KILLED_BAD_MESSAGE, false);
+    return;
+  }
+  std::string url_encoded_partition = net::EscapeQueryParamValue(
+      storage_partition_id, false);
+  // The SiteInstance of a given webview tag is based on the fact that it's
+  // a guest process in addition to which platform application the tag
+  // belongs to and what storage partition is in use, rather than the URL
+  // that the tag is being navigated to.
+  GURL guest_site(base::StringPrintf("%s://%s/%s?%s",
+                                     content::kGuestScheme,
+                                     embedder_extension_id.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.
+  GuestViewManager* guest_view_manager =
+      GuestViewManager::FromBrowserContext(
+          embedder_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(
+        embedder_render_process_host->GetBrowserContext(), guest_site);
+  }
+  WebContents::CreateParams params(
+      embedder_render_process_host->GetBrowserContext(),
+      guest_site_instance);
+  params.guest_delegate = this;
+  callback.Run(WebContents::Create(params));
+}
+
 void WebViewGuest::DidAttachToEmbedder() {
   std::string name;
   if (extra_params()->GetString(webview::kName, &name)) {
     // If the guest window's name is empty, then the WebView tag's name is
     // assigned. Otherwise, the guest window's name takes precedence over the
     // WebView tag's name.
     if (name_.empty())
       name_ = name;
   }
   ReportFrameNameChange(name_);
@@ skipping 24 matching lines @@
     } else {
       NOTREACHED();
     }
 
     // Once a new guest is attached to the DOM of the embedder page, then the
     // lifetime of the new guest is no longer managed by the opener guest.
     GetOpener()->pending_new_windows_.erase(this);
   }
 }
 
+void WebViewGuest::DidInitialize() {
+  script_executor_.reset(new extensions::ScriptExecutor(guest_web_contents(),
+                                                        &script_observers_));
+
+  notification_registrar_.Add(
+      this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
+      content::Source<WebContents>(guest_web_contents()));
+
+  notification_registrar_.Add(
+      this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
+      content::Source<WebContents>(guest_web_contents()));
+
+#if defined(OS_CHROMEOS)
+  chromeos::AccessibilityManager* accessibility_manager =
+      chromeos::AccessibilityManager::Get();
+  CHECK(accessibility_manager);
+  accessibility_subscription_ = accessibility_manager->RegisterCallback(
+      base::Bind(&WebViewGuest::OnAccessibilityStatusChanged,
+                 base::Unretained(this)));
+#endif
+
+  AttachWebViewHelpers(guest_web_contents());
+}
+
+
 void WebViewGuest::DidStopLoading() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEvent(new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
 }
 
 void WebViewGuest::EmbedderDestroyed() {
   // TODO(fsamuel): WebRequest event listeners for <webview> should survive
   // reparenting of a <webview> within a single embedder. Right now, we keep
   // around the browser state for the listener for the lifetime of the embedder.
   // Ideally, the lifetime of the listeners should match the lifetime of the
@@ skipping 124 matching lines @@
                                      const std::string& name) {
   if (!is_top_level)
     return;
 
   if (name_ == name)
     return;
 
   ReportFrameNameChange(name);
 }
 
-WebViewGuest* WebViewGuest::CreateNewGuestWindow(
+WebViewGuest* WebViewGuest::CreateNewGuestWebViewWindow(
     const content::OpenURLParams& params) {
   GuestViewManager* guest_manager =
       GuestViewManager::FromBrowserContext(browser_context());
-  // Allocate a new instance ID for the new guest.
-  int instance_id = guest_manager->GetNextInstanceID();
-
   // 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 = guest_web_contents()->GetSiteInstance()->GetSiteURL();
-  scoped_ptr<base::DictionaryValue> create_params(extra_params()->DeepCopy());
   const std::string storage_partition_id =
       GetStoragePartitionIdFromSiteURL(site_url);
-  create_params->SetString(webview::kStoragePartitionId, storage_partition_id);
+  base::DictionaryValue create_params;
+  create_params.SetString(webview::kStoragePartitionId, storage_partition_id);
 
   WebContents* new_guest_web_contents =
-      guest_manager->CreateGuest(guest_web_contents()->GetSiteInstance(),
-                                 instance_id,
-                                 create_params.Pass());
+      guest_manager->CreateGuest(
+          WebViewGuest::Type,
+          embedder_extension_id(),
+          embedder_web_contents()->GetRenderProcessHost()->GetID(),
+          create_params);
   WebViewGuest* new_guest =
       WebViewGuest::FromWebContents(new_guest_web_contents);
   new_guest->SetOpener(this);
 
   // Take ownership of |new_guest|.
   pending_new_windows_.insert(
       std::make_pair(new_guest, NewWindowInfo(params.url, std::string())));
 
   // Request permission to show the new window.
   RequestNewWindowPermission(params.disposition, gfx::Rect(),
@@ skipping 511 matching lines @@
     WebContents* web_contents) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(
           &ExtensionRendererState::RemoveWebView,
           base::Unretained(ExtensionRendererState::GetInstance()),
           web_contents->GetRenderProcessHost()->GetID(),
           web_contents->GetRoutingID()));
 }
 
+content::WebContents* WebViewGuest::CreateNewGuestWindow(
+    const content::WebContents::CreateParams& create_params) {
+  GuestViewManager* guest_manager =
+      GuestViewManager::FromBrowserContext(browser_context());
+  return guest_manager->CreateGuestWithWebContentsParams(
+      WebViewGuest::Type,
+      embedder_extension_id(),
+      embedder_web_contents()->GetRenderProcessHost()->GetID(),
+      create_params);
+}
+
 void WebViewGuest::SizeChanged(const gfx::Size& old_size,
                                const gfx::Size& new_size) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kOldHeight, old_size.height());
   args->SetInteger(webview::kOldWidth, old_size.width());
   args->SetInteger(webview::kNewHeight, new_size.height());
   args->SetInteger(webview::kNewWidth, new_size.width());
   DispatchEvent(
       new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
 }
@@ skipping 333 matching lines @@
     new_window_info.changed = new_window_info.url != info.url;
     it->second = new_window_info;
     return NULL;
   }
   if (params.disposition == CURRENT_TAB) {
     // This can happen for cross-site redirects.
     LoadURLWithParams(params.url, params.referrer, params.transition, source);
     return source;
   }
 
-  return CreateNewGuestWindow(params)->guest_web_contents();
+  return CreateNewGuestWebViewWindow(params)->guest_web_contents();
 }
 
 void WebViewGuest::WebContentsCreated(WebContents* source_contents,
                                       int opener_render_frame_id,
                                       const base::string16& frame_name,
                                       const GURL& target_url,
                                       content::WebContents* new_contents) {
   WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents);
   CHECK(guest);
   guest->SetOpener(this);
@@ skipping 38 matching lines @@
   base::DictionaryValue request_info;
   request_info.Set(webview::kInitialHeight,
                    base::Value::CreateIntegerValue(initial_bounds.height()));
   request_info.Set(webview::kInitialWidth,
                    base::Value::CreateIntegerValue(initial_bounds.width()));
   request_info.Set(webview::kTargetURL,
                    base::Value::CreateStringValue(new_window_info.url.spec()));
   request_info.Set(webview::kName,
                    base::Value::CreateStringValue(new_window_info.name));
   request_info.Set(webview::kWindowID,
-                   base::Value::CreateIntegerValue(guest->guest_instance_id()));
+                   base::Value::CreateIntegerValue(
+                      guest->GetGuestInstanceID()));
   // We pass in partition info so that window-s created through newwindow
   // API can use it to set their partition attribute.
   request_info.Set(webview::kStoragePartitionId,
                    base::Value::CreateStringValue(storage_partition_id));
   request_info.Set(webview::kWindowOpenDisposition,
                    base::Value::CreateStringValue(
                        WindowOpenDispositionToString(disposition)));
 
   RequestPermission(WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW,
                     request_info,
                     base::Bind(&WebViewGuest::OnWebViewNewWindowResponse,
                                base::Unretained(this),
-                               guest->guest_instance_id()),
+                               guest->GetGuestInstanceID()),
                                false /* allowed_by_default */);
 }
 
 void WebViewGuest::DestroyUnattachedWindows() {
   // Destroy() reaches in and removes the WebViewGuest from its opener's
   // pending_new_windows_ set. To avoid mutating the set while iterating, we
   // create a copy of the pending new windows set and iterate over the copy.
   PendingWindowMap pending_new_windows(pending_new_windows_);
   // Clean up unattached new windows opened by this guest.
   for (PendingWindowMap::const_iterator it = pending_new_windows.begin();
@@ skipping 22 matching lines @@
     bool allow,
     const std::string& user_input) {
   WebViewGuest* guest =
       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }