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

webkit/glue/webframeloaderclient_impl.cc

 // Copyright (c) 2006-2008 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 "config.h"
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 
@@ skipping 55 matching lines @@
 #include "webkit/glue/webview_delegate.h"
 #include "webkit/glue/webview_impl.h"
 
 using namespace WebCore;
 
 using base::Time;
 using base::TimeDelta;
 
 using WebKit::WebData;
 using WebKit::WebNavigationType;
+using WebKit::WebNavigationPolicy;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebVector;
 using WebKit::WrappedResourceRequest;
 using WebKit::WrappedResourceResponse;
 
 using webkit_glue::Alt404PageResourceFetcher;
 
 // Domain for internal error codes.
 static const char kInternalErrorDomain[] = "webkit_glue";
 
 // An internal error code.  Used to note a policy change error resulting from
 // dispatchDecidePolicyForMIMEType not passing the PolicyUse option.
 enum {
   ERR_POLICY_CHANGE = -10000,
 };
 
 WebFrameLoaderClient::WebFrameLoaderClient(WebFrameImpl* frame) :
     webframe_(frame),
     postpone_loading_data_(false),
     has_representation_(false),
     sent_initial_response_to_plugin_(false),
-    next_window_open_disposition_(IGNORE_ACTION) {
+    next_navigation_policy_(WebKit::WebNavigationPolicyIgnore) {
 }
 
 WebFrameLoaderClient::~WebFrameLoaderClient() {
 }
 
 void WebFrameLoaderClient::frameLoaderDestroyed() {
   // When the WebFrame was created, it had an extra reference given to it on
   // behalf of the Frame.  Since the WebFrame owns us, this extra ref also
   // serves to keep us alive until the FrameLoader is done with us.  The
   // FrameLoader calls this method when it's going away.  Therefore, we balance
@@ skipping 694 matching lines @@
   // All resources have not necessarily finished loading.
 }
 
 Frame* WebFrameLoaderClient::dispatchCreatePage() {
   struct WebCore::WindowFeatures features;
   Page* new_page = webframe_->frame()->page()->chrome()->createWindow(
       webframe_->frame(), FrameLoadRequest(), features);
 
   // Make sure that we have a valid disposition.  This should have been set in
   // the preceeding call to dispatchDecidePolicyForNewWindowAction.
-  DCHECK(next_window_open_disposition_ != IGNORE_ACTION);
-  WindowOpenDisposition disp = next_window_open_disposition_;
-  next_window_open_disposition_ = IGNORE_ACTION;
+  DCHECK(next_navigation_policy_ != WebKit::WebNavigationPolicyIgnore);
+  WebNavigationPolicy policy = next_navigation_policy_;
+  next_navigation_policy_ = WebKit::WebNavigationPolicyIgnore;
 
   // createWindow can return NULL (e.g., popup blocker denies the window).
   if (!new_page)
     return NULL;
 
-  WebViewImpl::FromPage(new_page)->set_window_open_disposition(disp);
+  WebViewImpl::FromPage(new_page)->set_initial_navigation_policy(policy);
   return new_page->mainFrame();
 }
 
 void WebFrameLoaderClient::dispatchShow() {
   WebViewImpl* webview = webframe_->GetWebViewImpl();
   WebViewDelegate* d = webview->delegate();
   if (d)
-    d->Show(webview, webview->window_open_disposition());
+    d->show(webview->initial_navigation_policy());
 }
 
 static bool TreatAsAttachment(const ResourceResponse& response) {
   const String& content_disposition =
       response.httpHeaderField("Content-Disposition");
   if (content_disposition.isEmpty())
     return false;
 
   // Some broken sites just send
   // Content-Disposition: ; filename="file"
@@ skipping 49 matching lines @@
   // NOTE: ERR_POLICY_CHANGE will be generated when action is not PolicyUse.
   (webframe_->frame()->loader()->*function)(action);
 }
 
 void WebFrameLoaderClient::dispatchDecidePolicyForNewWindowAction(
     WebCore::FramePolicyFunction function,
     const WebCore::NavigationAction& action,
     const WebCore::ResourceRequest& request,
     PassRefPtr<WebCore::FormState> form_state,
     const WebCore::String& frame_name) {
-  WindowOpenDisposition disposition;
-  if (!ActionSpecifiesDisposition(action, &disposition))
-    disposition = NEW_FOREGROUND_TAB;
+  WebNavigationPolicy navigation_policy;
+  if (!ActionSpecifiesNavigationPolicy(action, &navigation_policy))
+    navigation_policy = WebKit::WebNavigationPolicyNewForegroundTab;
 
   PolicyAction policy_action;
-  if (disposition == SAVE_TO_DISK) {
+  if (navigation_policy == WebKit::WebNavigationPolicyDownload) {
     policy_action = PolicyDownload;
   } else {
     policy_action = PolicyUse;
 
     // Remember the disposition for when dispatchCreatePage is called.  It is
     // unfortunate that WebCore does not provide us with any context when
     // creating or showing the new window that would allow us to avoid having
     // to keep this state.
-    next_window_open_disposition_ = disposition;
+    next_navigation_policy_ = navigation_policy;
   }
   (webframe_->frame()->loader()->*function)(policy_action);
 }
 
 void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(
     WebCore::FramePolicyFunction function,
     const WebCore::NavigationAction& action,
     const WebCore::ResourceRequest& request,
     PassRefPtr<WebCore::FormState> form_state) {
   PolicyAction policy_action = PolicyUse;
 
   WebViewImpl* wv = webframe_->GetWebViewImpl();
   WebViewDelegate* d = wv->delegate();
   // It is valid for this function to be invoked in code paths where the
   // the webview is closed.
   // The NULL check here is to fix a crash that seems strange
   // (see - https://bugs.webkit.org/show_bug.cgi?id=23554).
   if (d && !request.url().isNull()) {
-    WindowOpenDisposition disposition = CURRENT_TAB;
-    ActionSpecifiesDisposition(action, &disposition);
+    WebNavigationPolicy navigation_policy =
+        WebKit::WebNavigationPolicyCurrentTab;
+    ActionSpecifiesNavigationPolicy(action, &navigation_policy);
 
-    // Give the delegate a chance to change the disposition.
+    // Give the delegate a chance to change the navigation policy.
     const WebDataSourceImpl* ds = webframe_->GetProvisionalDataSourceImpl();
     if (ds) {
       GURL url = ds->request().url();
       if (url.SchemeIs(webkit_glue::kBackForwardNavigationScheme)) {
         HandleBackForwardNavigation(url);
-        disposition = IGNORE_ACTION;
+        navigation_policy = WebKit::WebNavigationPolicyIgnore;
       } else {
         bool is_redirect = ds->HasRedirectChain();
 
         WebNavigationType webnav_type =
             WebDataSourceImpl::NavigationTypeToWebNavigationType(action.type());
 
-        disposition = d->DispositionForNavigationAction(
-            wv, webframe_, ds->request(), webnav_type, disposition, is_redirect);
+        navigation_policy = d->PolicyForNavigationAction(
+            wv, webframe_, ds->request(), webnav_type, navigation_policy,
+            is_redirect);
       }
     }
 
-    if (disposition == CURRENT_TAB) {
+    if (navigation_policy == WebKit::WebNavigationPolicyCurrentTab) {
       policy_action = PolicyUse;
-    } else if (disposition == SAVE_TO_DISK) {
+    } else if (navigation_policy == WebKit::WebNavigationPolicyDownload) {
       policy_action = PolicyDownload;
     } else {
-      if (disposition != IGNORE_ACTION) {
+      if (navigation_policy != WebKit::WebNavigationPolicyIgnore) {
         GURL referrer = webkit_glue::StringToGURL(
             request.httpHeaderField("Referer"));
 
         d->OpenURL(webframe_->GetWebViewImpl(),
                    webkit_glue::KURLToGURL(request.url()),
                    referrer,
-                   disposition);
+                   navigation_policy);
       }
       policy_action = PolicyIgnore;
     }
   }
 
   (webframe_->frame()->loader()->*function)(policy_action);
 }
 
 void WebFrameLoaderClient::cancelPolicyCheck() {
   // FIXME
@@ skipping 492 matching lines @@
 
   return ObjectContentNone;
 }
 
 String WebFrameLoaderClient::overrideMediaType() const {
   // FIXME
   String rv;
   return rv;
 }
 
-bool WebFrameLoaderClient::ActionSpecifiesDisposition(
+bool WebFrameLoaderClient::ActionSpecifiesNavigationPolicy(
     const WebCore::NavigationAction& action,
-    WindowOpenDisposition* disposition) {
+    WebNavigationPolicy* policy) {
   if ((action.type() != NavigationTypeLinkClicked) ||
       !action.event()->isMouseEvent())
     return false;
 
   const MouseEvent* event = static_cast<const MouseEvent*>(action.event());
 #if defined(OS_WIN) || defined(OS_LINUX)
   const bool new_tab_modifier = (event->button() == 1) || event->ctrlKey();
 #elif defined(OS_MACOSX)
   const bool new_tab_modifier = (event->button() == 1) || event->metaKey();
 #endif
   const bool shift = event->shiftKey();
   const bool alt = event->altKey();
   if (!new_tab_modifier && !shift && !alt)
     return false;
 
-  DCHECK(disposition);
-  if (new_tab_modifier)
-    *disposition = shift ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
-  else
-    *disposition = shift ? NEW_WINDOW : SAVE_TO_DISK;
+  DCHECK(policy);
+  if (new_tab_modifier) {
+    if (shift) {
+      *policy = WebKit::WebNavigationPolicyNewForegroundTab;
+    } else {
+      *policy = WebKit::WebNavigationPolicyNewBackgroundTab;
+    }
+  } else {
+    if (shift) {
+      *policy = WebKit::WebNavigationPolicyNewWindow;
+    } else {
+      *policy = WebKit::WebNavigationPolicyDownload;
+    }
+  }
   return true;
 }
 
 NavigationGesture WebFrameLoaderClient::NavigationGestureForLastLoad() {
   // TODO(timsteele): isProcessingUserGesture() returns too many false positives
   // (see bug 1051891) to trust it and assign NavigationGestureUser, so
   // for now we assign Unknown in those cases and Auto otherwise.
   // (Issue 874811 known false negative as well).
   return webframe_->frame()->loader()->isProcessingUserGesture() ?
       NavigationGestureUnknown :
       NavigationGestureAuto;
 }
 
 void WebFrameLoaderClient::HandleBackForwardNavigation(const GURL& url) {
   DCHECK(url.SchemeIs(webkit_glue::kBackForwardNavigationScheme));
 
   std::string offset_str = url.ExtractFileName();
   int offset;
   if (!StringToInt(offset_str, &offset))
     return;
 
   WebViewDelegate* d = webframe_->GetWebViewImpl()->delegate();
   if (d)
     d->NavigateBackForwardSoon(offset);
 }