Reverting 28607.

webkit/glue/webframeloaderclient_impl.cc

 // Copyright (c) 2006-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 "config.h"
 
-#include <string>
-#include <vector>
-
 #include "Chrome.h"
 #include "CString.h"
 #include "Document.h"
 #include "DocumentLoader.h"
 #include "HTMLAppletElement.h"
 #include "HTMLFormElement.h"  // needed by FormState.h
 #include "HTMLNames.h"
 #include "FormState.h"
 #include "FrameLoader.h"
 #include "FrameLoadRequest.h"
 #include "HitTestResult.h"
 #include "MIMETypeRegistry.h"
 #include "MouseEvent.h"
 #include "Page.h"
 #include "PlatformString.h"
 #include "PluginData.h"
 #include "StringExtras.h"
 #include "WindowFeatures.h"
 #undef LOG
 
-#include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/string_util.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "webkit/api/public/WebForm.h"
 #include "webkit/api/public/WebFrameClient.h"
 #include "webkit/api/public/WebNode.h"
 #include "webkit/api/public/WebPlugin.h"
 #include "webkit/api/public/WebPluginParams.h"
 #include "webkit/api/public/WebSecurityOrigin.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLError.h"
 #include "webkit/api/public/WebVector.h"
 #include "webkit/api/src/WebDataSourceImpl.h"
 #include "webkit/api/src/WebPluginContainerImpl.h"
 #include "webkit/api/src/WebPluginLoadObserver.h"
 #include "webkit/api/src/WrappedResourceRequest.h"
 #include "webkit/api/src/WrappedResourceResponse.h"
 #include "webkit/glue/glue_util.h"
-#include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/webdevtoolsagent_impl.h"
 #include "webkit/glue/webframe_impl.h"
 #include "webkit/glue/webframeloaderclient_impl.h"
 #include "webkit/glue/webkit_glue.h"
-#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::WebDataSourceImpl;
 using WebKit::WebNavigationType;
 using WebKit::WebNavigationPolicy;
 using WebKit::WebNode;
 using WebKit::WebPlugin;
 using WebKit::WebPluginContainerImpl;
 using WebKit::WebPluginLoadObserver;
 using WebKit::WebPluginParams;
 using WebKit::WebString;
@@ skipping 349 matching lines @@
 //   dispatchDidCommitLoad()                                      -> DISPATCHES 1#anchor
 //   dispatchWillPerformClientRedirect()                          -> saves exp. source (1#anchor)
 //   -- redirect timer fires
 //   dispatchDidStartProvisionalLoad()                            -> appends 1#anchor (src) and 1 (dest)
 //   dispatchDidCancelClientRedirect()                            -> clears expected redirect
 //   dispatchDidCommitLoad()                                      -> DISPATCHES 1#anchor + 1
 //
 void WebFrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad() {
   WebDataSourceImpl* ds = webframe_->GetProvisionalDataSourceImpl();
   if (!ds) {
-    NOTREACHED() << "Got a server redirect when there is no provisional DS";
+    // Got a server redirect when there is no provisional DS!
+    ASSERT_NOT_REACHED();
     return;
   }
 
   // The server redirect may have been blocked.
   if (ds->request().isNull())
     return;
 
   // A provisional load should have started already, which should have put an
   // entry in our redirect chain.
-  DCHECK(ds->hasRedirectChain());
+  ASSERT(ds->hasRedirectChain());
 
   // The URL of the destination is on the provisional data source. We also need
   // to update the redirect chain to account for this addition (we do this
   // before the callback so the callback can look at the redirect chain to see
   // what happened).
-  ds->appendRedirect(ds->request().url());
+  ds->appendRedirect(webkit_glue::WebURLToKURL(ds->request().url()));
 
   if (webframe_->client())
     webframe_->client()->didReceiveServerRedirectForProvisionalLoad(webframe_);
 }
 
 // Called on both success and failure of a client redirect.
 void WebFrameLoaderClient::dispatchDidCancelClientRedirect() {
   // No longer expecting a client redirect.
   if (webframe_->client()) {
-    expected_client_redirect_src_ = GURL();
-    expected_client_redirect_dest_ = GURL();
+    expected_client_redirect_src_ = KURL();
+    expected_client_redirect_dest_ = KURL();
     webframe_->client()->didCancelClientRedirect(webframe_);
   }
 
   // No need to clear the redirect chain, since that data source has already
   // been deleted by the time this function is called.
 }
 
 void WebFrameLoaderClient::dispatchWillPerformClientRedirect(
     const KURL& url,
     double interval,
     double fire_date) {
   // Tells dispatchDidStartProvisionalLoad that if it sees this item it is a
   // redirect and the source item should be added as the start of the chain.
-  expected_client_redirect_src_ = webframe_->url();
-  expected_client_redirect_dest_ = webkit_glue::KURLToGURL(url);
+  expected_client_redirect_src_ = webkit_glue::WebURLToKURL(webframe_->url());
+  expected_client_redirect_dest_ = url;
 
   // TODO(timsteele): bug 1135512. Webkit does not properly notify us of
   // cancelling http > file client redirects. Since the FrameLoader's policy
   // is to never carry out such a navigation anyway, the best thing we can do
   // for now to not get confused is ignore this notification.
-  if (expected_client_redirect_dest_.SchemeIsFile() &&
-     (expected_client_redirect_src_.SchemeIs("http") ||
-      expected_client_redirect_src_.SchemeIsSecure())) {
-    expected_client_redirect_src_ = GURL();
-    expected_client_redirect_dest_ = GURL();
+  if (expected_client_redirect_dest_.isLocalFile() &&
+      expected_client_redirect_src_.protocolInHTTPFamily()) {
+    expected_client_redirect_src_ = KURL();
+    expected_client_redirect_dest_ = KURL();
     return;
   }
 
   if (webframe_->client()) {
     webframe_->client()->willPerformClientRedirect(
         webframe_,
-        expected_client_redirect_src_,
-        expected_client_redirect_dest_,
+        webkit_glue::KURLToWebURL(expected_client_redirect_src_),
+        webkit_glue::KURLToWebURL(expected_client_redirect_dest_),
         static_cast<unsigned int>(interval),
         static_cast<unsigned int>(fire_date));
   }
 }
 
 void WebFrameLoaderClient::dispatchDidChangeLocationWithinPage() {
   // Anchor fragment navigations are not normal loads, so we need to synthesize
   // some events for our delegate.
   WebViewImpl* webview = webframe_->GetWebViewImpl();
   if (webview->client())
     webview->client()->didStartLoading();
 
   WebDataSourceImpl* ds = webframe_->GetDataSourceImpl();
-  DCHECK(ds) << "DataSource NULL when navigating to reference fragment";
+  ASSERT(ds);  // Should not be null when navigating to a reference fragment!
   if (ds) {
-    GURL url = ds->request().url();
-    GURL chain_end = ds->endOfRedirectChain();
+    KURL url = webkit_glue::WebURLToKURL(ds->request().url());
+    KURL chain_end = ds->endOfRedirectChain();
     ds->clearRedirectChain();
 
     // Figure out if this location change is because of a JS-initiated client
     // redirect (e.g onload/setTimeout document.location.href=).
     // TODO(timsteele): (bugs 1085325, 1046841) We don't get proper redirect
     // performed/cancelled notifications across anchor navigations, so the
     // other redirect-tracking code in this class (see dispatch*ClientRedirect()
     // and dispatchDidStartProvisionalLoad) is insufficient to catch and
     // properly flag these transitions. Once a proper fix for this bug is
     // identified and applied the following block may no longer be required.
     bool was_client_redirect =
         (url == expected_client_redirect_dest_ &&
          chain_end == expected_client_redirect_src_) ||
         !webframe_->isProcessingUserGesture();
 
     if (was_client_redirect) {
-      if (webframe_->client())
-        webframe_->client()->didCompleteClientRedirect(webframe_, chain_end);
+      if (webframe_->client()) {
+        webframe_->client()->didCompleteClientRedirect(
+            webframe_, webkit_glue::KURLToWebURL(chain_end));
+      }
       ds->appendRedirect(chain_end);
       // Make sure we clear the expected redirect since we just effectively
       // completed it.
-      expected_client_redirect_src_ = GURL();
-      expected_client_redirect_dest_ = GURL();
+      expected_client_redirect_src_ = KURL();
+      expected_client_redirect_dest_ = KURL();
      }
 
     // Regardless of how we got here, we are navigating to a URL so we need to
     // add it to the redirect chain.
     ds->appendRedirect(url);
   }
 
   bool is_new_navigation;
   webview->DidCommitLoad(&is_new_navigation);
   if (webframe_->client()) {
@@ skipping 16 matching lines @@
 }
 
 void WebFrameLoaderClient::dispatchDidStartProvisionalLoad() {
   // In case a redirect occurs, we need this to be set so that the redirect
   // handling code can tell where the redirect came from. Server redirects
   // will occur on the provisional load, so we need to keep track of the most
   // recent provisional load URL.
   // See dispatchDidReceiveServerRedirectForProvisionalLoad.
   WebDataSourceImpl* ds = webframe_->GetProvisionalDataSourceImpl();
   if (!ds) {
-    NOTREACHED() << "Attempting to provisional load but there isn't one";
+    ASSERT_NOT_REACHED();
     return;
   }
-  GURL url = ds->request().url();
+  KURL url = webkit_glue::WebURLToKURL(ds->request().url());
 
   // Since the provisional load just started, we should have not gotten
   // any redirects yet.
-  DCHECK(!ds->hasRedirectChain());
+  ASSERT(!ds->hasRedirectChain());
 
   // If this load is what we expected from a client redirect, treat it as a
   // redirect from that original page. The expected redirect urls will be
   // cleared by DidCancelClientRedirect.
   bool completing_client_redirect = false;
-  if (expected_client_redirect_src_.is_valid()) {
+  if (expected_client_redirect_src_.isValid()) {
     // expected_client_redirect_dest_ could be something like
     // "javascript:history.go(-1)" thus we need to exclude url starts with
     // "javascript:". See bug: 1080873
-    DCHECK(expected_client_redirect_dest_.SchemeIs("javascript") ||
+    ASSERT(expected_client_redirect_dest_.protocolIs("javascript") ||
            expected_client_redirect_dest_ == url);
     ds->appendRedirect(expected_client_redirect_src_);
     completing_client_redirect = true;
   }
   ds->appendRedirect(url);
 
   if (webframe_->client()) {
     // As the comment for DidCompleteClientRedirect in webview_delegate.h
     // points out, whatever information its invocation contains should only
     // be considered relevant until the next provisional load has started.
     // So we first tell the delegate that the load started, and then tell it
     // about the client redirect the load is responsible for completing.
     webframe_->client()->didStartProvisionalLoad(webframe_);
     if (completing_client_redirect)
       webframe_->client()->didCompleteClientRedirect(
-          webframe_, expected_client_redirect_src_);
+          webframe_, webkit_glue::KURLToWebURL(expected_client_redirect_src_));
   }
 }
 
 void WebFrameLoaderClient::dispatchDidReceiveTitle(const String& title) {
   if (webframe_->client()) {
     webframe_->client()->didReceiveTitle(
         webframe_, webkit_glue::StringToWebString(title));
   }
 }
 
@@ skipping 65 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_navigation_policy_ != WebKit::WebNavigationPolicyIgnore);
+  ASSERT(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_initial_navigation_policy(policy);
   return new_page->mainFrame();
 }
 
 void WebFrameLoaderClient::dispatchShow() {
   WebViewImpl* webview = webframe_->GetWebViewImpl();
-  WebViewDelegate* d = webview->delegate();
-  if (d)
-    d->show(webview->initial_navigation_policy());
+  if (webview && webview->client())
+    webview->client()->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 87 matching lines @@
   // The NULL check here is to fix a crash that seems strange
   // (see - https://bugs.webkit.org/show_bug.cgi?id=23554).
   if (webframe_->client() && !request.url().isNull()) {
     WebNavigationPolicy navigation_policy =
         WebKit::WebNavigationPolicyCurrentTab;
     ActionSpecifiesNavigationPolicy(action, &navigation_policy);
 
     // 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)) {
+      KURL url = webkit_glue::WebURLToKURL(ds->request().url());
+      if (url.protocolIs(webkit_glue::kBackForwardNavigationScheme)) {
         HandleBackForwardNavigation(url);
         navigation_policy = WebKit::WebNavigationPolicyIgnore;
       } else {
         bool is_redirect = ds->hasRedirectChain();
 
         WebNavigationType webnav_type =
             WebDataSourceImpl::toWebNavigationType(action.type());
 
         RefPtr<WebCore::Node> node;
         for (const Event* event = action.event(); event;
@@ skipping 321 matching lines @@
   //
   // item_impl->SetTitle(webkit_glue::StringToStdWString(title));
 }
 
 String WebFrameLoaderClient::userAgent(const KURL& url) {
   return webkit_glue::StdStringToString(
       webkit_glue::GetUserAgent(webkit_glue::KURLToGURL(url)));
 }
 
 void WebFrameLoaderClient::savePlatformDataToCachedFrame(WebCore::CachedFrame*) {
-  NOTREACHED() << "Page cache should be disabled";
+  // The page cache should be disabled.
+  ASSERT_NOT_REACHED();
 }
 
 void WebFrameLoaderClient::transitionToCommittedFromCachedFrame(WebCore::CachedFrame*) {
   ASSERT_NOT_REACHED();
 }
 
 // Called when the FrameLoader goes into a state in which a new page load
 // will occur.
 void WebFrameLoaderClient::transitionToCommittedForNewPage() {
   makeDocumentView();
 }
 
 bool WebFrameLoaderClient::canCachePage() const {
   // Since we manage the cache, always report this page as non-cacheable to
   // FrameLoader.
   return false;
 }
 
 // Downloading is handled in the browser process, not WebKit. If we get to this
 // point, our download detection code in the ResourceDispatcherHost is broken!
 void WebFrameLoaderClient::download(ResourceHandle* handle,
                                     const ResourceRequest& request,
                                     const ResourceRequest& initialRequest,
                                     const ResourceResponse& response) {
-  NOTREACHED();
+  ASSERT_NOT_REACHED();
 }
 
 PassRefPtr<Frame> WebFrameLoaderClient::createFrame(
     const KURL& url,
     const String& name,
     HTMLFrameOwnerElement* owner_element,
     const String& referrer,
     bool allows_scrolling,
     int margin_width,
     int margin_height) {
@@ skipping 48 matching lines @@
   if (!element->renderer())
     return NULL;
 
   return container;
 }
 
 // This method gets called when a plugin is put in place of html content
 // (e.g., acrobat reader).
 void WebFrameLoaderClient::redirectDataToPlugin(Widget* pluginWidget) {
   plugin_widget_ = static_cast<WebPluginContainerImpl*>(pluginWidget);
-  DCHECK(plugin_widget_.get());
+  ASSERT(plugin_widget_.get());
 }
 
 PassRefPtr<Widget> WebFrameLoaderClient::createJavaAppletWidget(
                                            const IntSize& size,
                                            HTMLAppletElement* element,
                                            const KURL& /* base_url */,
                                            const Vector<String>& param_names,
                                            const Vector<String>& param_values) {
   return createPlugin(size, element, KURL(), param_names, param_values,
       "application/x-java-applet", false);
@@ skipping 26 matching lines @@
     return ObjectContentNetscapePlugin;
 
   if (MIMETypeRegistry::isSupportedNonImageMIMEType(mime_type))
     return ObjectContentFrame;
 
   return ObjectContentNone;
 }
 
 String WebFrameLoaderClient::overrideMediaType() const {
   // FIXME
-  String rv;
-  return rv;
+  return String();
 }
 
 bool WebFrameLoaderClient::ActionSpecifiesNavigationPolicy(
     const WebCore::NavigationAction& action,
     WebNavigationPolicy* policy) {
   if ((action.type() != NavigationTypeLinkClicked) ||
       !action.event()->isMouseEvent())
     return false;
 
   const MouseEvent* event = static_cast<const MouseEvent*>(action.event());
   return WebViewImpl::NavigationPolicyFromMouseEvent(event->button(),
       event->ctrlKey(), event->shiftKey(), event->altKey(), event->metaKey(),
       policy);
 }
 
-void WebFrameLoaderClient::HandleBackForwardNavigation(const GURL& url) {
-  DCHECK(url.SchemeIs(webkit_glue::kBackForwardNavigationScheme));
+void WebFrameLoaderClient::HandleBackForwardNavigation(const KURL& url) {
+  ASSERT(url.protocolIs(webkit_glue::kBackForwardNavigationScheme));
 
-  std::string offset_str = url.ExtractFileName();
-  int offset;
-  if (!StringToInt(offset_str, &offset))
+  bool ok;
+  int offset = url.lastPathComponent().toIntStrict(&ok);
+  if (!ok)
     return;
 
   WebViewImpl* webview = webframe_->GetWebViewImpl();
   if (webview->client())
     webview->client()->navigateBackForwardSoon(offset);
 }
 
 PassOwnPtr<WebPluginLoadObserver> WebFrameLoaderClient::GetPluginLoadObserver() {
   WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(
       webframe_->frame()->loader()->activeDocumentLoader());
   return ds->releasePluginLoadObserver();
 }