Move allocate instance id to chrome/.

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 123 matching lines @@
     case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW:
       return webview::kPermissionTypeNewWindow;
     case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK:
       return webview::kPermissionTypePointerLock;
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
+std::string GetStoragePartitionIdFromSiteURL(const GURL& site_url) {
+  const std::string& partition_id = site_url.query();
+  bool persist_storage = site_url.path().find("persist") != std::string::npos;
+  return (persist_storage ? webview::kPersistPrefix : "") + partition_id;
+}
+
 void RemoveWebViewEventListenersOnIOThread(
     void* profile,
     const std::string& extension_id,
     int embedder_process_id,
     int view_instance_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   ExtensionWebRequestEventRouter::GetInstance()->RemoveWebViewEventListeners(
       profile,
       extension_id,
       embedder_process_id,
@@ skipping 51 matching lines @@
       base::Bind(&WebViewGuest::OnAccessibilityStatusChanged,
                  base::Unretained(this)));
 #endif
 
   AttachWebViewHelpers(guest_web_contents);
 }
 
 // static
 const char WebViewGuest::Type[] = "webview";
 
-// static.
+// 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 142 matching lines @@
   DispatchEvent(
       new GuestViewBase::Event(webview::kEventConsoleMessage, args.Pass()));
   return true;
 }
 
 void WebViewGuest::CloseContents(WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEvent(new GuestViewBase::Event(webview::kEventClose, args.Pass()));
 }
 
-void WebViewGuest::DidAttach() {
+void WebViewGuest::DidAttach(const base::DictionaryValue& extra_params) {
+  std::string src;
+  if (extra_params.GetString("src", &src) && !src.empty())
+    NavigateGuest(src);
+
   if (GetOpener()) {
     // We need to do a navigation here if the target URL has changed between
     // the time the WebContents was created and the time it was attached.
     // We also need to do an initial navigation if a RenderView was never
     // created for the new window in cases where there is no referrer.
     PendingWindowMap::iterator it =
         GetOpener()->pending_new_windows_.find(this);
     if (it != GetOpener()->pending_new_windows_.end()) {
       const NewWindowInfo& new_window_info = it->second;
       NavigateGuest(new_window_info.url.spec());
@@ skipping 96 matching lines @@
     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);
 
-  scoped_ptr<base::DictionaryValue> create_params(extra_params()->DeepCopy());
-  const std::string& storage_partition_id = site_url.query();
-  bool persist_storage =
-      site_url.path().find("persist") != std::string::npos;
   WebContents* new_guest_web_contents =
       guest_manager->CreateGuest(guest_web_contents()->GetSiteInstance(),
                                  instance_id,
-                                 storage_partition_id,
-                                 persist_storage,
                                  create_params.Pass());
   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.
@@ skipping 829 matching lines @@
     bool user_gesture,
     content::WebContents* new_contents) {
   WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents);
   if (!guest)
     return;
   PendingWindowMap::iterator it = pending_new_windows_.find(guest);
   if (it == pending_new_windows_.end())
     return;
   const NewWindowInfo& new_window_info = it->second;
 
+  // Retrieve the opener partition info if we have it.
+  const GURL& site_url = new_contents->GetSiteInstance()->GetSiteURL();
+  std::string storage_partition_id = GetStoragePartitionIdFromSiteURL(site_url);
+
   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()));
+  // 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()),
                                false /* allowed_by_default */);
@@ skipping 31 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();
 }