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/debug/stack_trace.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 122 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;
+
+  printf("site_url: %s\n", site_url.possibly_invalid_spec().c_str());
+  printf("partition would be: %s\n", site_url.query().c_str());
+  printf("extracted: id: %s, persist_storage: %d\n",
+         partition_id.c_str(), persist_storage);
+
+  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 29 matching lines @@
       script_executor_(new extensions::ScriptExecutor(guest_web_contents,
                                                       &script_observers_)),
       pending_context_menu_request_id_(0),
       next_permission_request_id_(0),
       is_overriding_user_agent_(false),
       pending_reload_on_attachment_(false),
       main_frame_id_(0),
       chromevox_injected_(false),
       find_helper_(this),
       javascript_dialog_helper_(this) {
+  printf("++++ %s\n", __PRETTY_FUNCTION__);
   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 =
@@ skipping 128 matching lines @@
     SetUserAgentOverride("");
   }
 
   GuestViewBase::Attach(embedder_web_contents, args);
 
   AddWebViewToExtensionRendererState();
 }
 
 bool WebViewGuest::HandleContextMenu(
     const content::ContextMenuParams& params) {
+  printf("++++ %s\n", __PRETTY_FUNCTION__);
   ContextMenuDelegate* menu_delegate =
       ContextMenuDelegate::FromWebContents(guest_web_contents());
   DCHECK(menu_delegate);
 
   pending_menu_ = menu_delegate->BuildMenu(guest_web_contents(), params);
 
   // Pass it to embedder.
   int request_id = ++pending_context_menu_request_id_;
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   scoped_ptr<base::ListValue> items =
@@ skipping 19 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()) {
+    printf("DidAttach, src = %s\n", src.c_str());
+    NavigateGuest(src);
+  } else {
+    printf("DidAttach, no src\n");
+  }
+
   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 109 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(guestview::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 256 matching lines @@
       content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
       GURL(),
       content::StoragePartition::OriginMatcherFunction(),
       remove_since,
       base::Time::Now(),
       callback);
   return true;
 }
 
 WebViewGuest::~WebViewGuest() {
+  printf("++++ %s\n", __PRETTY_FUNCTION__);
 }
 
 void WebViewGuest::DidCommitProvisionalLoadForFrame(
     int64 frame_id,
     const base::string16& frame_unique_name,
     bool is_main_frame,
     const GURL& url,
     content::PageTransition transition_type,
     content::RenderViewHost* render_view_host) {
   find_helper_.CancelAllFindSessions();
@@ skipping 429 matching lines @@
     : callback(callback),
       permission_type(permission_type),
       allowed_by_default(allowed_by_default) {
 }
 
 WebViewGuest::PermissionResponseInfo::~PermissionResponseInfo() {
 }
 
 void WebViewGuest::ShowContextMenu(int request_id,
                                    const MenuItemVector* items) {
+  printf("++++ %s\n", __PRETTY_FUNCTION__);
   if (!pending_menu_.get())
     return;
 
   // Make sure this was the correct request.
   if (request_id != pending_context_menu_request_id_)
     return;
 
   // TODO(lazyboy): Implement.
   DCHECK(!items);
 
@@ skipping 94 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;
 
+  printf("Begin RequestNewWindowPermission\n");
+  printf("Try new contents\n");
+  // 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()));
+  request_info.Set(guestview::kStoragePartitionId,

[Fady Samuel, 2014/05/29 20:35:23]

Comment explaining why we need to send the partition ID.

[lazyboy, 2014/05/30 05:48:21]

Done.

+                   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();
 }