Refactor FileSystem

content/renderer/pepper/pepper_directory_reader_host.cc

 // Copyright (c) 2013 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 "content/renderer/pepper/pepper_directory_reader_host.h"
 
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
+#include "content/renderer/pepper/null_file_system_callback_dispatcher.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/file_type_conversion.h"
 #include "ppapi/shared_impl/ppb_file_ref_shared.h"
 #include "ppapi/thunk/enter.h"
-#include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
-#include "webkit/plugins/ppapi/ppb_file_system_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
 using ppapi::thunk::EnterResource;
 using ppapi::thunk::PPB_FileRef_API;
 using webkit::ppapi::PPB_FileRef_Impl;
 
 namespace content {
 
 namespace {
 
@@ skipping 10 matching lines @@
 base::FilePath::StringType UTF8StringToFilePathString(const std::string& str) {
 #if defined(OS_WIN)
   return UTF8ToWide(str);
 #elif defined(OS_POSIX)
   return str;
 #else
 #error "Unsupported platform."
 #endif
 }
 
-class ReadDirectoryCallback : public fileapi::FileSystemCallbackDispatcher {
+class ReadDirectoryCallback : public NullFileSystemCallbackDispatcher {
  public:
   typedef base::Callback<void (const PepperDirectoryReaderHost::Entries&,
                                bool, int32_t)>
       OnReadDirectoryCallback;
 
   explicit ReadDirectoryCallback(const OnReadDirectoryCallback& callback)
       : callback_(callback) {}
   virtual ~ReadDirectoryCallback() {}
 
-  virtual void DidSucceed() OVERRIDE {
-    NOTREACHED();
-  }
-
-  virtual void DidReadMetadata(const base::PlatformFileInfo& file_info,
-                               const base::FilePath& platform_path) OVERRIDE {
-    NOTREACHED();
-  }
-
-  virtual void DidCreateSnapshotFile(
-      const base::PlatformFileInfo& file_info,
-      const base::FilePath& platform_path) OVERRIDE {
-    NOTREACHED();
-  }
-
   virtual void DidReadDirectory(
       const std::vector<base::FileUtilProxy::Entry>& entries,
       bool has_more) OVERRIDE {
     callback_.Run(entries, has_more, PP_OK);
   }
 
-  virtual void DidOpenFileSystem(const std::string& name,
-                                 const GURL& root) OVERRIDE {
-    NOTREACHED();
-  }
-
-  virtual void DidFail(base::PlatformFileError error) OVERRIDE {
-    callback_.Run(PepperDirectoryReaderHost::Entries(),
-                  false,
-                  ppapi::PlatformFileErrorToPepperError(error));
-  }
-
-  virtual void DidWrite(int64 bytes, bool complete) OVERRIDE {
-    NOTREACHED();
-  }
-
-  virtual void DidOpenFile(base::PlatformFile file) OVERRIDE {
-    NOTREACHED();
+  virtual void DidFail(int pp_error) OVERRIDE {

[yzshen1, 2013/04/08 21:05:16]

int32_t, please.

[victorhsieh, 2013/04/08 23:44:38]

Done.

+    callback_.Run(PepperDirectoryReaderHost::Entries(), false, pp_error);
   }
 
  private:
   OnReadDirectoryCallback callback_;
 };
 
 }  // namespace
 
 PepperDirectoryReaderHost::PepperDirectoryReaderHost(
     RendererPpapiHost* host,
@@ skipping 58 matching lines @@
   std::string dir_path = directory_ref_->GetCreateInfo().path;
   if (dir_path[dir_path.size() - 1] != '/')
     dir_path += '/';
   base::FilePath::StringType dir_file_path =
       UTF8StringToFilePathString(dir_path);
 
   for (Entries::const_iterator it = entries.begin();
        it != entries.end(); ++it) {
     EntryData data;
     data.file_ref = PPB_FileRef_Impl::CreateInternal(
-        directory_ref_->file_system()->pp_resource(),
+        pp_instance(),
+        directory_ref_->file_system_resource(),
         FilePathStringToUTF8String(dir_file_path + it->name));
     if (!data.file_ref) {
       entry_data_.clear();
       return false;
     }
     data.file_type = it->is_directory ?
                      PP_FILETYPE_DIRECTORY : PP_FILETYPE_REGULAR;
     entry_data_.push_back(data);
   }
 
@@ skipping 20 matching lines @@
                                                      file_types));
 }
 
 PepperDirectoryReaderHost::EntryData::EntryData() {
 }
 
 PepperDirectoryReaderHost::EntryData::~EntryData() {
 }
 
 }  // namespace content