Update src/content/renderer to reflect WEBKIT_FRAME_TO_DOCUMENT_API_MOVE

content/renderer/render_view.cc

 // Copyright (c) 2011 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 "content/renderer/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 525 matching lines @@
 void RenderView::PluginCrashed(const FilePath& plugin_path) {
   Send(new ViewHostMsg_CrashedPlugin(routing_id_, plugin_path));
 }
 
 WebPlugin* RenderView::CreatePluginNoCheck(WebFrame* frame,
                                            const WebPluginParams& params) {
   webkit::npapi::WebPluginInfo info;
   bool found;
   std::string mime_type;
   Send(new ViewHostMsg_GetPluginInfo(
-      routing_id_, params.url, frame->top()->url(), params.mimeType.utf8(),
-      &found, &info, &mime_type));
+      routing_id_, params.url, frame->top()->document().url(),
+      params.mimeType.utf8(), &found, &info, &mime_type));
   if (!found || !webkit::npapi::IsPluginEnabled(info))
     return NULL;
 
   bool pepper_plugin_was_registered = false;
   scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
       pepper_delegate_.CreatePepperPlugin(info.path,
                                           &pepper_plugin_was_registered));
   if (pepper_plugin_was_registered) {
     if (pepper_module)
       return CreatePepperPlugin(frame, params, info.path, pepper_module.get());
@@ skipping 18 matching lines @@
   delegate->SetContentAreaFocus(has_focus());
 }
 
 void RenderView::UnregisterPluginDelegate(WebPluginDelegateProxy* delegate) {
   plugin_delegates_.erase(delegate);
 }
 
 bool RenderView::OnMessageReceived(const IPC::Message& message) {
   WebFrame* main_frame = webview() ? webview()->mainFrame() : NULL;
   if (main_frame)
-    content::GetContentClient()->SetActiveURL(main_frame->url());
+    content::GetContentClient()->SetActiveURL(main_frame->document().url());
 
   ObserverListBase<RenderViewObserver>::Iterator it(observers_);
   RenderViewObserver* observer;
   while ((observer = it.GetNext()) != NULL)
     if (observer->OnMessageReceived(message))
       return true;
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderView, message)
     IPC_MESSAGE_HANDLER(ViewMsg_Navigate, OnNavigate)
@@ skipping 659 matching lines @@
   if (shared_popup_counter_->data > kMaximumNumberOfUnacknowledgedPopups)
     return NULL;
 
   ViewHostMsg_CreateWindow_Params params;
   params.opener_id = routing_id_;
   params.user_gesture = creator->isProcessingUserGesture();
   params.window_container_type = WindowFeaturesToContainerType(features);
   params.session_storage_namespace_id = session_storage_namespace_id_;
   params.frame_name = frame_name;
   params.opener_frame_id = creator->identifier();
-  params.opener_url = creator->url();
-  params.opener_security_origin = creator->securityOrigin().toString().utf8();
+  params.opener_url = creator->document().url();
+  params.opener_security_origin =
+      creator->document().securityOrigin().toString().utf8();
   if (!request.isNull())
     params.target_url = request.url();
 
   int32 routing_id = MSG_ROUTING_NONE;
   int64 cloned_session_storage_namespace_id;
   bool opener_suppressed = creator->willSuppressOpenerInNewFrame();
 
   render_thread_->Send(
       new ViewHostMsg_CreateWindow(params,
                                    &routing_id,
@@ skipping 10 matching lines @@
                                         shared_popup_counter_,
                                         routing_id,
                                         cloned_session_storage_namespace_id,
                                         frame_name);
   view->opened_by_user_gesture_ = params.user_gesture;
 
   // Record whether the creator frame is trying to suppress the opener field.
   view->opener_suppressed_ = opener_suppressed;
 
   // Record the security origin of the creator.
-  GURL creator_url(creator->securityOrigin().toString().utf8());
+  GURL creator_url(creator->document().securityOrigin().toString().utf8());
   if (!creator_url.is_valid() || !creator_url.IsStandard())
     creator_url = GURL();
   view->creator_url_ = creator_url;
 
   // Copy over the alternate error page URL so we can have alt error pages in
   // the new render view (we don't need the browser to send the URL back down).
   view->alternate_error_page_url_ = alternate_error_page_url_;
 
   return view->webview();
 }
@@ skipping 19 matching lines @@
   DCHECK(!external_popup_menu_.get());
   external_popup_menu_.reset(
       new ExternalPopupMenu(this, popup_menu_info, popup_menu_client));
   return external_popup_menu_.get();
 }
 
 RenderWidgetFullscreenPepper* RenderView::CreatePepperFullscreenContainer(
     webkit::ppapi::PluginInstance* plugin) {
   GURL active_url;
   if (webview() && webview()->mainFrame())
-    active_url = GURL(webview()->mainFrame()->url());
+    active_url = GURL(webview()->mainFrame()->document().url());
   RenderWidgetFullscreenPepper* widget = RenderWidgetFullscreenPepper::Create(
       routing_id_, render_thread_, plugin, active_url);
   widget->show(WebKit::WebNavigationPolicyIgnore);
   return widget;
 }
 
 WebStorageNamespace* RenderView::createSessionStorageNamespace(unsigned quota) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess))
     return WebStorageNamespace::createSessionStorageNamespace(quota);
   CHECK(session_storage_namespace_id_ != kInvalidSessionStorageNamespaceId);
@@ skipping 216 matching lines @@
   ipc_params.accept_types = params.acceptTypes;
 
   return ScheduleFileChooser(ipc_params, chooser_completion);
 }
 
 void RenderView::runModalAlertDialog(
     WebFrame* frame, const WebString& message) {
   RunJavaScriptMessage(ui::MessageBoxFlags::kIsJavascriptAlert,
                        message,
                        string16(),
-                       frame->url(),
+                       frame->document().url(),
                        NULL);
 }
 
 bool RenderView::runModalConfirmDialog(
     WebFrame* frame, const WebString& message) {
   return RunJavaScriptMessage(ui::MessageBoxFlags::kIsJavascriptConfirm,
                               message,
                               string16(),
-                              frame->url(),
+                              frame->document().url(),
                               NULL);
 }
 
 bool RenderView::runModalPromptDialog(
     WebFrame* frame, const WebString& message, const WebString& default_value,
     WebString* actual_value) {
   string16 result;
   bool ok = RunJavaScriptMessage(ui::MessageBoxFlags::kIsJavascriptPrompt,
                                  message,
                                  default_value,
-                                 frame->url(),
+                                 frame->document().url(),
                                  &result);
   if (ok)
     actual_value->assign(result);
   return ok;
 }
 
 bool RenderView::runModalBeforeUnloadDialog(
     WebFrame* frame, const WebString& message) {
   // If we are swapping out, we have already run the beforeunload handler.
   // TODO(creis): Fix OnSwapOut to clear the frame without running beforeunload
   // at all, to avoid running it twice.
   if (is_swapped_out_)
     return true;
 
   bool success = false;
   // This is an ignored return value, but is included so we can accept the same
   // response as RunJavaScriptMessage.
   string16 ignored_result;
   SendAndRunNestedMessageLoop(new ViewHostMsg_RunBeforeUnloadConfirm(
-      routing_id_, frame->url(), message, &success, &ignored_result));
+      routing_id_, frame->document().url(), message,
+      &success, &ignored_result));
   return success;
 }
 
 void RenderView::showContextMenu(
     WebFrame* frame, const WebContextMenuData& data) {
   ContextMenuParams params = ContextMenuParams(data);
   // Serializing a GURL longer than content::kMaxURLChars will fail, so don't do
   // it.  We replace it with an empty GURL so the appropriate items are disabled
   // in the context menu.
   // TODO(jcivelli): http://crbug.com/45160 This prevents us from saving large
@@ skipping 344 matching lines @@
       IsNonLocalTopLevelNavigation(url, frame, type)) {
     GURL referrer(request.httpHeaderField(WebString::fromUTF8("Referer")));
     // Reset these counters as the RenderView could be reused for the next
     // navigation.
     page_id_ = -1;
     last_page_id_sent_to_browser_ = -1;
     OpenURL(url, referrer, default_policy);
     return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
   }
 
-  GURL old_url(frame->url());
+  GURL old_url(frame->document().url());
 
   // Detect when we're crossing a permission-based boundary (e.g. into or out of
   // an extension or app origin, leaving a WebUI page, etc). We only care about
   // top-level navigations within the current tab (as opposed to, for example,
   // opening a new window). But we sometimes navigate to about:blank to clear a
   // tab, and we want to still allow that.
   //
   // Note: we do this only for GET requests because our mechanism for switching
   // processes only issues GET requests. In particular, POST requests don't
   // work, because this mechanism does not preserve form POST data. If it
@@ skipping 63 matching lines @@
       // Must be a JavaScript navigation, which appears as "other".
       type == WebKit::WebNavigationTypeOther;
 
   // Recognize if this navigation is from a link with rel=noreferrer and
   // target=_blank attributes, in which case the opener will be suppressed. If
   // so, it is safe to load cross-site pages in a separate process, so we
   // should let the browser handle it.
   bool is_noreferrer_and_blank_target =
       // Frame should be top level and not yet navigated.
       frame->parent() == NULL &&
-      frame->url().isEmpty() &&
+      frame->document().url().isEmpty() &&
       historyBackListCount() < 1 &&
       historyForwardListCount() < 1 &&
       // Links with rel=noreferrer will have no Referer field, and their
       // resulting frame will have its window.opener suppressed.
       // TODO(creis): should add a request.httpReferrer() method to help avoid
       // typos on the unusual spelling of Referer.
       request.httpHeaderField(WebString::fromUTF8("Referer")).isNull() &&
       opener_suppressed_ &&
       frame->opener() == NULL &&
       // Links with target=_blank will have no name.
@@ skipping 352 matching lines @@
   completed_client_redirect_src_ = GURL();
 
   // Check whether we have new encoding name.
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
 void RenderView::didClearWindowObject(WebFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidClearWindowObject(frame));
 
-  GURL frame_url = frame->url();
+  GURL frame_url = frame->document().url();
   if (BindingsPolicy::is_web_ui_enabled(enabled_bindings_) &&
       (frame_url.SchemeIs(chrome::kChromeUIScheme) ||
       frame_url.SchemeIs(chrome::kDataScheme))) {
     GetWebUIBindings()->set_message_sender(this);
     GetWebUIBindings()->set_routing_id(routing_id_);
     GetWebUIBindings()->BindToJavascript(frame, "chrome");
   }
 }
 
 void RenderView::didCreateDocumentElement(WebFrame* frame) {
   // Notify the browser about non-blank documents loading in the top frame.
-  GURL url = frame->url();
+  GURL url = frame->document().url();
   if (url.is_valid() && url.spec() != chrome::kAboutBlankURL) {
     if (frame == webview()->mainFrame())
       Send(new ViewHostMsg_DocumentAvailableInMainFrame(routing_id_));
   }
 
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidCreateDocumentElement(frame));
 }
 
 void RenderView::didReceiveTitle(WebFrame* frame, const WebString& title,
@@ skipping 163 matching lines @@
     WebFrame* frame, unsigned identifier) {
   NavigationState* navigation_state =
       NavigationState::FromDataSource(frame->dataSource());
   if (!navigation_state->use_error_page())
     return;
 
   // Display error page, if appropriate.
   int http_status_code = navigation_state->http_status_code();
   if (http_status_code == 404) {
     // On 404s, try a remote search page as a fallback.
-    const GURL& frame_url = frame->url();
+    const GURL& document_url = frame->document().url();
 
-    const GURL& error_page_url = GetAlternateErrorPageURL(frame_url, HTTP_404);
+    const GURL& error_page_url =
+        GetAlternateErrorPageURL(document_url, HTTP_404);
     if (error_page_url.is_valid()) {
       WebURLError original_error;
       original_error.domain = "http";
       original_error.reason = 404;
-      original_error.unreachableURL = frame_url;
+      original_error.unreachableURL = document_url;
 
       navigation_state->set_alt_error_page_fetcher(
           new AltErrorPageResourceFetcher(
               error_page_url, frame, original_error,
               NewCallback(this, &RenderView::AltErrorPageFinished)));
       return;
     }
   }
 
   content::GetContentClient()->renderer()->ShowErrorPage(
@@ skipping 136 matching lines @@
 }
 
 void RenderView::openFileSystem(
     WebFrame* frame,
     WebFileSystem::Type type,
     long long size,
     bool create,
     WebFileSystemCallbacks* callbacks) {
   DCHECK(callbacks);
 
-  WebSecurityOrigin origin = frame->securityOrigin();
+  WebSecurityOrigin origin = frame->document().securityOrigin();
   if (origin.isEmpty()) {
     // Uninitialized document?
     callbacks->didFail(WebKit::WebFileErrorAbort);
     return;
   }
 
   ChildThread::current()->file_system_dispatcher()->OpenFileSystem(
       GURL(origin.toString()), static_cast<fileapi::FileSystemType>(type),
       size, create, new WebFileSystemCallbackDispatcher(callbacks));
 }
 
 void RenderView::queryStorageUsageAndQuota(
     WebFrame* frame,
     WebStorageQuotaType type,
     WebStorageQuotaCallbacks* callbacks) {
   DCHECK(frame);
-  WebSecurityOrigin origin = frame->securityOrigin();
+  WebSecurityOrigin origin = frame->document().securityOrigin();
   if (origin.isEmpty()) {
     // Uninitialized document?
     callbacks->didFail(WebKit::WebStorageQuotaErrorAbort);
     return;
   }
   ChildThread::current()->quota_dispatcher()->QueryStorageUsageAndQuota(
       GURL(origin.toString()), type, callbacks);
 }
 
 void RenderView::requestStorageQuota(
     WebFrame* frame,
     WebStorageQuotaType type,
     unsigned long long requested_size,
     WebStorageQuotaCallbacks* callbacks) {
   DCHECK(frame);
-  WebSecurityOrigin origin = frame->securityOrigin();
+  WebSecurityOrigin origin = frame->document().securityOrigin();
   if (origin.isEmpty()) {
     // Uninitialized document?
     callbacks->didFail(WebKit::WebStorageQuotaErrorAbort);
     return;
   }
   ChildThread::current()->quota_dispatcher()->RequestStorageQuota(
       routing_id(), GURL(origin.toString()), type, requested_size, callbacks);
 }
 
 // webkit_glue::WebPluginPageDelegate -----------------------------------------
@@ skipping 458 matching lines @@
 void RenderView::OnScriptEvalRequest(const string16& frame_xpath,
                                      const string16& jscript,
                                      int id,
                                      bool notify_result) {
   EvaluateScript(frame_xpath, jscript, id, notify_result);
 }
 
 void RenderView::OnCSSInsertRequest(const std::wstring& frame_xpath,
                                     const std::string& css,
                                     const std::string& id) {
-  WebFrame* web_frame = GetChildFrame(frame_xpath);
-  if (!web_frame)
+  WebFrame* frame = GetChildFrame(frame_xpath);
+  if (!frame)
     return;
 
-  web_frame->insertStyleText(WebString::fromUTF8(css), WebString::fromUTF8(id));
+  frame->document().insertStyleText(WebString::fromUTF8(css),
+                                    WebString::fromUTF8(id));
 }
 
 void RenderView::OnAllowBindings(int enabled_bindings_flags) {
   enabled_bindings_ |= enabled_bindings_flags;
 }
 
 void RenderView::OnSetWebUIProperty(const std::string& name,
                                     const std::string& value) {
   DCHECK(BindingsPolicy::is_web_ui_enabled(enabled_bindings_));
   GetWebUIBindings()->SetProperty(name, value);
@@ skipping 809 matching lines @@
       routing_id_, minimum_percent, maximum_percent, remember));
 }
 
 void RenderView::zoomLevelChanged() {
   bool remember = !webview()->mainFrame()->document().isPluginDocument();
 
   // Tell the browser which url got zoomed so it can update the menu and the
   // saved values if necessary
   Send(new ViewHostMsg_DidZoomURL(
       routing_id_, webview()->zoomLevel(), remember,
-      GURL(webview()->mainFrame()->url())));
+      GURL(webview()->mainFrame()->document().url())));
 }
 
 void RenderView::registerProtocolHandler(const WebString& scheme,
                                          const WebString& base_url,
                                          const WebString& url,
                                          const WebString& title) {
   GURL base(base_url);
   GURL absolute_url = base.Resolve(UTF16ToUTF8(url));
   if (base.GetOrigin() != absolute_url.GetOrigin()) {
     return;
@@ skipping 38 matching lines @@
       type != WebKit::WebNavigationTypeFormResubmitted &&
       type != WebKit::WebNavigationTypeBackForward) {
     // The opener relationship between the new window and the parent allows the
     // new window to script the parent and vice versa. This is not allowed if
     // the origins of the two domains are different. This can be treated as a
     // top level navigation and routed back to the host.
     WebKit::WebFrame* opener = frame->opener();
     if (!opener) {
       return true;
     } else {
-      if (url.GetOrigin() != GURL(opener->url()).GetOrigin())
+      if (url.GetOrigin() != GURL(opener->document().url()).GetOrigin())
         return true;
     }
   }
   return false;
 }
 
 void RenderView::OnAsyncFileOpened(base::PlatformFileError error_code,
                                    IPC::PlatformFileForTransit file_for_transit,
                                    int message_id) {
   pepper_delegate_.OnAsyncFileOpened(
@@ skipping 44 matching lines @@
     const webkit_glue::CustomContextMenuContext& custom_context) {
   if (custom_context.is_pepper_menu)
     pepper_delegate_.OnContextMenuClosed(custom_context);
   else
     context_menu_node_.reset();
 }
 
 void RenderView::OnNetworkStateChanged(bool online) {
   WebNetworkStateNotifier::setOnLine(online);
 }