Use WebWidget from the WebKit API. This change also makes...

chrome/renderer/render_view.cc

 // Copyright (c) 2009 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/renderer/render_view.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 88 matching lines @@
 using webkit_glue::AutofillForm;
 using webkit_glue::PasswordForm;
 using webkit_glue::PasswordFormDomManager;
 using webkit_glue::SearchableFormData;
 using WebKit::WebConsoleMessage;
 using WebKit::WebData;
 using WebKit::WebDataSource;
 using WebKit::WebDragData;
 using WebKit::WebForm;
 using WebKit::WebHistoryItem;
+using WebKit::WebNavigationPolicy;
 using WebKit::WebNavigationType;
 using WebKit::WebPopupMenuInfo;
 using WebKit::WebRect;
 using WebKit::WebScriptSource;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
+using WebKit::WebVector;
+using WebKit::WebWidget;
 using WebKit::WebWorker;
 using WebKit::WebWorkerClient;
-using WebKit::WebVector;
 
 //-----------------------------------------------------------------------------
 
 // define to write the time necessary for thumbnail/DOM text retrieval,
 // respectively, into the system debug log
 // #define TIME_BITMAP_RETRIEVAL
 // #define TIME_TEXT_RETRIEVAL
 
 // maximum number of characters in the document to index, any text beyond this
 // point will be clipped
@@ skipping 421 matching lines @@
 
 bool RenderView::CaptureThumbnail(WebView* view,
                                   int w,
                                   int h,
                                   SkBitmap* thumbnail,
                                   ThumbnailScore* score) {
 #ifdef TIME_BITMAP_RETRIEVAL
   double begin = time_util::GetHighResolutionTimeNow();
 #endif
 
-  view->Layout();
-  const WebSize& size = view->GetSize();
+  view->layout();
+  const WebSize& size = view->size();
 
   skia::PlatformCanvas canvas;
   if (!canvas.initialize(size.width, size.height, true))
     return false;
-  view->Paint(&canvas, WebRect(0, 0, size.width, size.height));
+  view->paint(&canvas, WebRect(0, 0, size.width, size.height));
 
   skia::BitmapPlatformDevice& device =
       static_cast<skia::BitmapPlatformDevice&>(canvas.getTopPlatformDevice());
 
   const SkBitmap& src_bmp = device.accessBitmap(false);
 
   SkRect dest_rect;
   dest_rect.set(0, 0, SkIntToScalar(w), SkIntToScalar(h));
   float dest_aspect = dest_rect.width() / dest_rect.height();
 
@@ skipping 887 matching lines @@
 }
 
 void RenderView::DidDestroyScriptContextForFrame(WebFrame* webframe) {
   EventBindings::HandleContextDestroyed(webframe);
 }
 
 void RenderView::DidCreateIsolatedScriptContext(WebFrame* webframe) {
   EventBindings::HandleContextCreated(webframe);
 }
 
-WindowOpenDisposition RenderView::DispositionForNavigationAction(
+WebNavigationPolicy RenderView::PolicyForNavigationAction(
     WebView* webview,
     WebFrame* frame,
     const WebURLRequest& request,
     WebNavigationType type,
-    WindowOpenDisposition disposition,
+    WebNavigationPolicy default_policy,
     bool is_redirect) {
   // A content initiated navigation may have originated from a link-click,
   // script, drag-n-drop operation, etc.
   bool is_content_initiated =
       NavigationState::FromDataSource(frame->GetProvisionalDataSource())->
           is_content_initiated();
 
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = request.url();
 
   // We only care about navigations that are 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.
-  if (disposition == CURRENT_TAB && is_content_initiated &&
-      frame->GetParent() == NULL && !url.SchemeIs(chrome::kAboutScheme)) {
+  if (default_policy == WebKit::WebNavigationPolicyCurrentTab &&
+      is_content_initiated && frame->GetParent() == NULL &&
+      !url.SchemeIs(chrome::kAboutScheme)) {
     // When we received such unsolicited navigations, we sometimes want to
     // punt them up to the browser to handle.
     if (BindingsPolicy::is_dom_ui_enabled(enabled_bindings_) ||
         BindingsPolicy::is_extension_enabled(enabled_bindings_) ||
         frame->GetInViewSourceMode() ||
         url.SchemeIs(chrome::kViewSourceScheme) ||
         url.SchemeIs(chrome::kPrintScheme)) {
-      OpenURL(webview, url, GURL(), disposition);
-      return IGNORE_ACTION;  // Suppress the load here.
+      OpenURL(webview, url, GURL(), default_policy);
+      return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
 
   // Detect when a page is "forking" a new tab that can be safely rendered in
   // its own process.  This is done by sites like Gmail that try to open links
   // in new windows without script connections back to the original page.  We
   // treat such cases as browser navigations (in which we will create a new
   // renderer for a cross-site navigation), rather than WebKit navigations.
   //
   // We use the following heuristic to decide whether to fork a new page in its
   // own process:
   // The parent page must open a new tab to about:blank, set the new tab's
   // window.opener to null, and then redirect the tab to a cross-site URL using
   // JavaScript.
   bool is_fork =
       // Must start from a tab showing about:blank, which is later redirected.
       frame->GetURL() == GURL("about:blank") &&
       // Must be the first real navigation of the tab.
       GetHistoryBackListCount() < 1 &&
       GetHistoryForwardListCount() < 1 &&
       // The parent page must have set the child's window.opener to null before
       // redirecting to the desired URL.
       frame->GetOpener() == NULL &&
       // Must be a top-level frame.
       frame->GetParent() == NULL &&
       // Must not have issued the request from this page.
       is_content_initiated &&
       // Must be targeted at the current tab.
-      disposition == CURRENT_TAB &&
+      default_policy == WebKit::WebNavigationPolicyCurrentTab &&
       // Must be a JavaScript navigation, which appears as "other".
       type == WebKit::WebNavigationTypeOther;
   if (is_fork) {
     // Open the URL via the browser, not via WebKit.
-    OpenURL(webview, url, GURL(), disposition);
-    return IGNORE_ACTION;
+    OpenURL(webview, url, GURL(), default_policy);
+    return WebKit::WebNavigationPolicyIgnore;
   }
 
-  return disposition;
+  return default_policy;
 }
 
 void RenderView::RunJavaScriptAlert(WebFrame* webframe,
                                     const std::wstring& message) {
   RunJavaScriptMessage(MessageBoxFlags::kIsJavascriptAlert,
                        message,
                        std::wstring(),
                        webframe->GetURL(),
                        NULL);
 }
@@ skipping 319 matching lines @@
   NOTIMPLEMENTED();
 #endif
 }
 
 WebWorker* RenderView::CreateWebWorker(WebWorkerClient* client) {
   return new WebWorkerProxy(client, RenderThread::current(), routing_id_);
 }
 
 void RenderView::OpenURL(WebView* webview, const GURL& url,
                          const GURL& referrer,
-                         WindowOpenDisposition disposition) {
-  Send(new ViewHostMsg_OpenURL(routing_id_, url, referrer, disposition));
+                         WebNavigationPolicy policy) {
+  Send(new ViewHostMsg_OpenURL(
+      routing_id_, url, referrer, NavigationPolicyToDisposition(policy)));
 }
 
 void RenderView::DidContentsSizeChange(WebWidget* webwidget,
                                        int new_width,
                                        int new_height) {
   // We don't always want to send the change messages over IPC, only if we've
   // be put in that mode by getting a |ViewMsg_EnableIntrinsicWidthChangedMode|
   // message.
   // TODO(rafaelw): Figure out where the best place to set this for extensions
   // is. It isn't clean to test for ExtensionView by examining the
@@ skipping 12 matching lines @@
   }
 }
 
 // We are supposed to get a single call to Show for a newly created RenderView
 // that was created via RenderView::CreateWebView.  So, we wait until this
 // point to dispatch the ShowView message.
 //
 // This method provides us with the information about how to display the newly
 // created RenderView (i.e., as a constrained popup or as a new tab).
 //
-void RenderView::Show(WebWidget* webwidget, WindowOpenDisposition disposition) {
+void RenderView::show(WebNavigationPolicy policy) {
   DCHECK(!did_show_) << "received extraneous Show call";
   DCHECK(opener_id_ != MSG_ROUTING_NONE);
 
   if (did_show_)
     return;
   did_show_ = true;
 
   // NOTE: initial_pos_ may still have its default values at this point, but
   // that's okay.  It'll be ignored if disposition is not NEW_POPUP, or the
   // browser process will impose a default position otherwise.
-  Send(new ViewHostMsg_ShowView(opener_id_, routing_id_, disposition,
-      initial_pos_, opened_by_user_gesture_, creator_url_));
+  Send(new ViewHostMsg_ShowView(opener_id_, routing_id_,
+      NavigationPolicyToDisposition(policy), initial_pos_,
+      opened_by_user_gesture_, creator_url_));
   SetPendingWindowRect(initial_pos_);
 }
 
-void RenderView::CloseWidgetSoon(WebWidget* webwidget) {
+void RenderView::closeWidgetSoon() {
   if (!popup_notification_visible_)
-    RenderWidget::CloseWidgetSoon(webwidget);
+    RenderWidget::closeWidgetSoon();
 }
 
-void RenderView::RunModal(WebWidget* webwidget) {
+void RenderView::runModal() {
   DCHECK(did_show_) << "should already have shown the view";
 
   IPC::SyncMessage* msg = new ViewHostMsg_RunModal(routing_id_);
 
   msg->set_pump_messages_event(modal_dialog_event_.get());
   Send(msg);
 }
 
 void RenderView::SyncNavigationState() {
   if (!webview())
@@ skipping 772 matching lines @@
 
   Send(new ViewHostMsg_ClosePage_ACK(routing_id_,
                                      new_render_process_host_id,
                                      new_request_id));
 }
 
 void RenderView::OnThemeChanged() {
 #if defined(OS_WIN)
   gfx::NativeTheme::instance()->CloseHandles();
   gfx::Rect view_rect(0, 0, size_.width(), size_.height());
-  DidInvalidateRect(webwidget_, view_rect);
+  didInvalidateRect(view_rect);
 #else  // defined(OS_WIN)
   // TODO(port): we don't support theming on non-Windows platforms yet
   NOTIMPLEMENTED();
 #endif
 }
 
 void RenderView::DidAddHistoryItem() {
   // We don't want to update the history length for the start page
   // navigation.
   WebFrame* main_frame = webview()->GetMainFrame();
@@ skipping 265 matching lines @@
   // occurred.
   if (acc_obj_id >= 0)
     Send(new ViewHostMsg_AccessibilityFocusChange(routing_id_, acc_obj_id));
 
 #else  // defined(OS_WIN)
   // TODO(port): accessibility not yet implemented
   NOTIMPLEMENTED();
 #endif
 }
 
+void RenderView::DidMovePlugin(const WebPluginGeometry& move) {
+  SchedulePluginMove(move);
+}
+
 void RenderView::SendPasswordForms(WebFrame* frame) {
   std::vector<WebForm> forms;
   frame->GetForms(&forms);
 
   std::vector<PasswordForm> password_forms;
   for (size_t i = 0; i < forms.size(); ++i) {
     const WebForm& form = forms[i];
 
     // Respect autocomplete=off.
     if (form.isAutoCompleteEnabled()) {
       scoped_ptr<PasswordForm> password_form(
           PasswordFormDomManager::CreatePasswordForm(form));
       if (password_form.get())
         password_forms.push_back(*password_form);
     }
   }
 
   if (!password_forms.empty())
     Send(new ViewHostMsg_PasswordFormsSeen(routing_id_, password_forms));
 }
 
 void RenderView::Print(WebFrame* frame, bool script_initiated) {
   DCHECK(frame);
   if (print_helper_.get() == NULL) {
     print_helper_.reset(new PrintWebViewHelper(this));
   }
   print_helper_->Print(frame, script_initiated);
 }