Refactor FileSystemOperation to take callback for each method.

webkit/fileapi/file_system_url_request_job.cc

 // Copyright (c) 2012 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 "webkit/fileapi/file_system_url_request_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
-#include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using net::URLRequest;
 using net::URLRequestJob;
 using net::URLRequestStatus;
 
 namespace fileapi {
 
@@ skipping 10 matching lines @@
       new net::HttpResponseHeaders(std::string(kStatus, kStatusLen));
 
   // Tell WebKit never to cache this content.
   std::string cache_control(net::HttpRequestHeaders::kCacheControl);
   cache_control.append(": no-cache");
   headers->AddHeader(cache_control);
 
   return headers;
 }
 
-class FileSystemURLRequestJob::CallbackDispatcher
-    : public FileSystemCallbackDispatcher {
- public:
-  // An instance of this class must be created by Create()
-  // (so that we do not leak ownerships).
-  static scoped_ptr<FileSystemCallbackDispatcher> Create(
-      FileSystemURLRequestJob* job) {
-    return scoped_ptr<FileSystemCallbackDispatcher>(
-        new CallbackDispatcher(job));
-  }
-
-  // fileapi::FileSystemCallbackDispatcher overrides.
-  virtual void DidSucceed() OVERRIDE {
-    NOTREACHED();
-  }
-
-  virtual void DidReadMetadata(const base::PlatformFileInfo& file_info,
-                               const FilePath& platform_path) OVERRIDE {
-    job_->DidGetMetadata(file_info, platform_path);
-  }
-
-  virtual void DidReadDirectory(
-      const std::vector<base::FileUtilProxy::Entry>& entries,
-      bool has_more) OVERRIDE {
-    NOTREACHED();
-  }
-
-  virtual void DidWrite(int64 bytes, bool complete) OVERRIDE {
-    NOTREACHED();
-  }
-
-  virtual void DidOpenFileSystem(const std::string& name,
-                                 const GURL& root_path) OVERRIDE {
-    NOTREACHED();
-  }
-
-  virtual void DidFail(base::PlatformFileError error_code) OVERRIDE {
-    int rv = net::ERR_FILE_NOT_FOUND;
-    if (error_code == base::PLATFORM_FILE_ERROR_INVALID_URL)
-      rv = net::ERR_INVALID_URL;
-    job_->NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
-  }
-
- private:
-  explicit CallbackDispatcher(FileSystemURLRequestJob* job) : job_(job) {
-    DCHECK(job_);
-  }
-
-  // TODO(adamk): Get rid of the need for refcounting here by
-  // allowing FileSystemOperations to be cancelled.
-  scoped_refptr<FileSystemURLRequestJob> job_;
-  DISALLOW_COPY_AND_ASSIGN(CallbackDispatcher);
-};
-
 FileSystemURLRequestJob::FileSystemURLRequestJob(
     URLRequest* request, FileSystemContext* file_system_context,
     scoped_refptr<base::MessageLoopProxy> file_thread_proxy)
     : URLRequestJob(request),
       file_system_context_(file_system_context),
       file_thread_proxy_(file_thread_proxy),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       stream_(NULL),
       is_directory_(false),
       remaining_bytes_(0) {
@@ skipping 98 matching lines @@
     return 200;
   return URLRequestJob::GetResponseCode();
 }
 
 void FileSystemURLRequestJob::StartAsync() {
   if (!request_)
     return;
   FileSystemOperationInterface* operation =
       file_system_context_->CreateFileSystemOperation(
           request_->url(),
-          CallbackDispatcher::Create(this),
           file_thread_proxy_);
   if (!operation) {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
                                 net::ERR_INVALID_URL));
     return;
   }
-  operation->GetMetadata(request_->url());
+  operation->GetMetadata(
+      request_->url(),
+      base::Bind(&FileSystemURLRequestJob::DidGetMetadata, this));
 }
 
 void FileSystemURLRequestJob::DidGetMetadata(
+    base::PlatformFileError error_code,
     const base::PlatformFileInfo& file_info,
     const FilePath& platform_path) {
+  if (error_code != base::PLATFORM_FILE_OK) {
+    NotifyFailed(error_code == base::PLATFORM_FILE_ERROR_INVALID_URL ?
+                 net::ERR_INVALID_URL : net::ERR_FILE_NOT_FOUND);
+    return;
+  }
+
   // We may have been orphaned...
   if (!request_)
     return;
 
   is_directory_ = file_info.is_directory;
 
   if (!byte_range_.ComputeBounds(file_info.size)) {
     NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
     return;
   }
@@ skipping 70 matching lines @@
   }
 
   return false;
 }
 
 void FileSystemURLRequestJob::NotifyFailed(int rv) {
   NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 }  // namespace fileapi