Remove ContentBrowserClient::GuestWebContentsAttached

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 171 matching lines @@
 #endif  // defined(ENABLE_FULL_PRINTING)
 #endif  // defined(ENABLE_PRINTING)
   PDFTabHelper::CreateForWebContents(contents);
 }
 
 }  // namespace
 
 WebViewGuest::WebViewGuest(int guest_instance_id,
                            WebContents* guest_web_contents,
                            const std::string& embedder_extension_id)
-   :  GuestView<WebViewGuest>(guest_instance_id,
-                              guest_web_contents,
-                              embedder_extension_id),
+   :  GuestView<WebViewGuest>(guest_instance_id),
       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) {
+  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 =
@@ skipping 165 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::Attach(WebContents* embedder_web_contents,
-                          const base::DictionaryValue& args) {
+void WebViewGuest::DidAttachToEmbedder() {
   std::string name;
-  args.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;
+  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_);
 
   std::string user_agent_override;
-  if (args.GetString(webview::kParameterUserAgentOverride,
-                     &user_agent_override)) {
+  if (extra_params()->GetString(webview::kParameterUserAgentOverride,
+                                &user_agent_override)) {
     SetUserAgentOverride(user_agent_override);
   } else {
     SetUserAgentOverride("");
   }
 
-  GuestViewBase::Attach(embedder_web_contents, args);
+  std::string src;
+  if (extra_params()->GetString("src", &src) && !src.empty())
+    NavigateGuest(src);
 
-  AddWebViewToExtensionRendererState();
+  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;
+      if (new_window_info.changed || !guest_web_contents()->HasOpener())
+        NavigateGuest(new_window_info.url.spec());
+    } 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::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
@@ skipping 46 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(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());
-    } 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);
-  }
-
-  if (pending_reload_on_attachment_) {
-    pending_reload_on_attachment_ = false;
-    guest_web_contents()->GetController().Reload(false);
-  }
-}
-
 void WebViewGuest::FindReply(WebContents* source,
                              int request_id,
                              int number_of_matches,
                              const gfx::Rect& selection_rect,
                              int active_match_ordinal,
                              bool final_update) {
   find_helper_.FindReply(request_id, number_of_matches, selection_rect,
                          active_match_ordinal, final_update);
 }
 
@@ skipping 320 matching lines @@
   if (action != DEFAULT)
     RecordUserInitiatedUMA(info, allow);
 
   pending_permission_requests_.erase(request_itr);
 
   return allow ? SET_PERMISSION_ALLOWED : SET_PERMISSION_DENIED;
 }
 
 void WebViewGuest::SetUserAgentOverride(
     const std::string& user_agent_override) {
+  if (!attached())
+    return;
   is_overriding_user_agent_ = !user_agent_override.empty();
   if (is_overriding_user_agent_) {
     content::RecordAction(UserMetricsAction("WebView.Guest.OverrideUA"));
   }
   guest_web_contents()->SetUserAgentOverride(user_agent_override);
 }
 
 void WebViewGuest::Stop() {
   guest_web_contents()->Stop();
 }
@@ skipping 187 matching lines @@
   find_helper_.CancelAllFindSessions();
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    guest_web_contents()->GetRenderProcessHost()->GetID());
   args->SetString(webview::kReason, TerminationStatusToString(status));
   DispatchEvent(new GuestViewBase::Event(webview::kEventExit, args.Pass()));
 }
 
 void WebViewGuest::UserAgentOverrideSet(const std::string& user_agent) {
+  if (!attached())
+    return;
   content::NavigationController& controller =
       guest_web_contents()->GetController();
   content::NavigationEntry* entry = controller.GetVisibleEntry();
   if (!entry)
     return;
   entry->SetIsOverridingUserAgent(!user_agent.empty());
-  if (!attached()) {
-    // We cannot reload now because all resource loads are suspended until
-    // attachment.
-    pending_reload_on_attachment_ = true;
-    return;
-  }
   guest_web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::RenderViewReady() {
   // The guest RenderView should always live in an isolated guest process.
   CHECK(guest_web_contents()->GetRenderProcessHost()->IsIsolatedGuest());
   Send(new ChromeViewMsg_SetName(guest_web_contents()->GetRoutingID(), name_));
 }
 
 void WebViewGuest::ReportFrameNameChange(const std::string& name) {
@@ skipping 122 matching lines @@
 
   RequestPermission(
       WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK,
       request_info,
       base::Bind(&WebViewGuest::OnWebViewPointerLockPermissionResponse,
                  base::Unretained(this),
                  callback),
       false /* allowed_by_default */);
 }
 
+void WebViewGuest::WillAttachToEmbedder() {
+  // We must install the mapping from guests to WebViews prior to resuming
+  // suspended resource loads so that the WebRequest API will catch resource
+  // requests.
+  AddWebViewToExtensionRendererState();
+}
+
 content::JavaScriptDialogManager*
     WebViewGuest::GetJavaScriptDialogManager() {
   return &javascript_dialog_helper_;
 }
 
 content::ColorChooser* WebViewGuest::OpenColorChooser(
     WebContents* web_contents,
     SkColor color,
     const std::vector<content::ColorSuggestion>& suggestions) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
@@ skipping 246 matching lines @@
   // navigation to perform upon attachment. Navigation initializes a lot of
   // state that assumes an embedder exists, such as RenderWidgetHostViewGuest.
   // Navigation also resumes resource loading which we don't want to allow
   // until attachment.
   if (!attached()) {
     WebViewGuest* opener = GetOpener();
     PendingWindowMap::iterator it =
         opener->pending_new_windows_.find(this);
     if (it == opener->pending_new_windows_.end())
       return NULL;
-    const NewWindowInfo& old_target_url = it->second;
-    NewWindowInfo new_window_info(params.url, old_target_url.name);
+    const NewWindowInfo& info = it->second;
+    NewWindowInfo new_window_info(params.url, info.name);
+    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();
@@ skipping 104 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();
 }