Modify ResourceFetcher to use WebURLLoader instead of ResourceHandle....

webkit/glue/resource_fetcher.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 "webkit/glue/resource_fetcher.h"
 
-#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "webkit/api/public/WebKit.h"
+#include "webkit/api/public/WebKitClient.h"
+#include "webkit/api/public/WebURLError.h"
+#include "webkit/api/public/WebURLLoader.h"
+#include "webkit/api/public/WebURLRequest.h"
+#include "webkit/api/public/WebURL.h"
+#include "webkit/glue/webframe.h"
 
-MSVC_PUSH_WARNING_LEVEL(0);
-#include "FrameLoader.h"
-#include "FrameLoaderClient.h"
-#include "ResourceHandle.h"
-#include "ResourceRequest.h"
-MSVC_POP_WARNING();
+using base::TimeDelta;
+using WebKit::WebURLError;
+using WebKit::WebURLLoader;
+using WebKit::WebURLRequest;
+using WebKit::WebURLResponse;
 
-#undef LOG
-#include "base/logging.h"
-#include "webkit/glue/glue_util.h"
-#include "net/url_request/url_request_status.h"
+namespace webkit_glue {
 
-using WebCore::ResourceError;
-using WebCore::ResourceHandle;
-using WebCore::ResourceResponse;
-
-ResourceFetcher::ResourceFetcher(const GURL& url, WebCore::Frame* frame,
-                                 Delegate* d)
-    : url_(url), delegate_(d), completed_(false) {
+ResourceFetcher::ResourceFetcher(const GURL& url, WebFrame* frame,
+                                 Callback* c)
+    : url_(url), callback_(c), completed_(false) {

[brettw, 2009/07/07 15:59:53]

Can you put these initializers on separate lines?

[darin (slow to review), 2009/07/07 16:20:52]

OK

   // Can't do anything without a frame.  However, delegate can be NULL (so we
   // can do a http request and ignore the results).
   DCHECK(frame);
   Start(frame);
 }
 
 ResourceFetcher::~ResourceFetcher() {
   if (!completed_ && loader_.get())
     loader_->cancel();
-  loader_ = NULL;
 }
 
 void ResourceFetcher::Cancel() {
   if (!completed_) {
     loader_->cancel();
     completed_ = true;
   }
 }
 
-void ResourceFetcher::Start(WebCore::Frame* frame) {
-  WebCore::ResourceRequest request(webkit_glue::GURLToKURL(url_));
-  WebCore::ResourceResponse response;
-  frame->loader()->client()->dispatchWillSendRequest(NULL, 0, request,
-                                                     response);
+void ResourceFetcher::Start(WebFrame* frame) {
+  WebURLRequest request(url_);
+  frame->DispatchWillSendRequest(&request);
 
-  loader_ = ResourceHandle::create(request, this, NULL, false, false);
+  loader_.reset(WebKit::webKitClient()->createURLLoader());
+  loader_->loadAsynchronously(request, this);
 }
 
 /////////////////////////////////////////////////////////////////////////////
-// ResourceHandleClient methods
-void ResourceFetcher::didReceiveResponse(ResourceHandle* resource_handle,
-                                         const ResourceResponse& response) {
-  ASSERT(!completed_);
-  // It's safe to use the ResourceResponse copy constructor
-  // (xmlhttprequest.cpp uses it).
+// WebURLLoaderClient methods
+
+void ResourceFetcher::willSendRequest(
+    WebURLLoader* loader, WebURLRequest& new_request,
+    const WebURLResponse& redirect_response) {
+}
+
+void ResourceFetcher::didSendData(
+    WebURLLoader* loader, unsigned long long bytes_sent,
+    unsigned long long total_bytes_to_be_sent) {
+}
+
+void ResourceFetcher::didReceiveResponse(
+    WebURLLoader* loader, const WebURLResponse& response) {
+  DCHECK(!completed_);
   response_ = response;
 }
 
-void ResourceFetcher::didReceiveData(ResourceHandle* resource_handle,
-                                     const char* data, int length,
-                                     int total_length) {
-  ASSERT(!completed_);
-  if (length <= 0)
-    return;
+void ResourceFetcher::didReceiveData(
+    WebURLLoader* loader, const char* data, int data_length,
+    long long total_data_length) {
+  DCHECK(!completed_);
+  DCHECK(data_length > 0);
 
-  data_.append(data, length);
+  data_.append(data, data_length);
 }
 
-void ResourceFetcher::didFinishLoading(ResourceHandle* resource_handle) {
-  ASSERT(!completed_);
+void ResourceFetcher::didFinishLoading(WebURLLoader* loader) {
+  DCHECK(!completed_);
   completed_ = true;
 
-  if (delegate_)
-    delegate_->OnURLFetchComplete(response_, data_);
+  if (callback_)
+    callback_->Run(response_, data_);
 }
 
-void ResourceFetcher::didFail(ResourceHandle* resource_handle,
-                              const ResourceError& error) {
-  ASSERT(!completed_);
+void ResourceFetcher::didFail(WebURLLoader* loader, const WebURLError& error) {
+  DCHECK(!completed_);
   completed_ = true;
 
-  // Go ahead and tell our delegate that we're done.  Send an empty
-  // ResourceResponse and string.
-  if (delegate_)
-    delegate_->OnURLFetchComplete(ResourceResponse(), std::string());
+  // Go ahead and tell our delegate that we're done.
+  if (callback_)
+    callback_->Run(WebURLResponse(), std::string());
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // A resource fetcher with a timeout
 
 ResourceFetcherWithTimeout::ResourceFetcherWithTimeout(
-    const GURL& url, WebCore::Frame* frame, double timeout_secs, Delegate* d)
-    : ResourceFetcher(url, frame, d) {
-  timeout_timer_.reset(new FetchTimer(this,
-      &ResourceFetcherWithTimeout::TimeoutFired));
-  timeout_timer_->startOneShot(timeout_secs);
+    const GURL& url, WebFrame* frame, int timeout_secs, Callback* c)
+    : ResourceFetcher(url, frame, c) {
+  timeout_timer_.Start(TimeDelta::FromSeconds(timeout_secs), this,
+                       &ResourceFetcherWithTimeout::TimeoutFired);
 }
 
-void ResourceFetcherWithTimeout::TimeoutFired(FetchTimer* timer) {
+void ResourceFetcherWithTimeout::TimeoutFired() {
   if (!completed_) {
     loader_->cancel();
-    didFail(NULL, ResourceError());
+    didFail(NULL, WebURLError());
   }
 }
+
+}  // namespace webkit_glue