Stop returning the true root path of each filesystem from openFileSystem....

webkit/tools/test_shell/simple_file_writer.cc

 // Copyright (c) 2011 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/tools/test_shell/simple_file_writer.h"
 
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
+#include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
+using fileapi::FileSystemCallbackDispatcher;
+using fileapi::FileSystemContext;
+using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperation;
-using fileapi::FileSystemCallbackDispatcher;
 using fileapi::WebFileWriterBase;
 using WebKit::WebFileWriterClient;
 using WebKit::WebString;
 using WebKit::WebURL;
 
 net::URLRequestContext* SimpleFileWriter::request_context_ = NULL;
 
 // Helper class to proxy to write and truncate calls to the IO thread,
 // and to proxy the results back to the main thead. There is a one-to-one
 // relationship between SimpleFileWriters and IOThreadBackends.
 class SimpleFileWriter::IOThreadProxy
     : public base::RefCountedThreadSafe<SimpleFileWriter::IOThreadProxy> {
  public:
-  explicit IOThreadProxy(const base::WeakPtr<SimpleFileWriter>& simple_writer)
+  explicit IOThreadProxy(const base::WeakPtr<SimpleFileWriter>& simple_writer,
+                         FileSystemContext* file_system_context)
       : simple_writer_(simple_writer),
-        operation_(NULL) {
+        operation_(NULL),
+        file_system_context_(file_system_context) {
     // The IO thread needs to be running for this class to work.
     SimpleResourceLoaderBridge::EnsureIOThread();
     io_thread_ = SimpleResourceLoaderBridge::GetIoThread();
     main_thread_ = base::MessageLoopProxy::CreateForCurrentThread();
   }
 
   virtual ~IOThreadProxy() {
   }
 
   void Truncate(const FilePath& path, int64 offset) {
@@ skipping 69 matching lines @@
                                    const FilePath& root_path) {
       NOTREACHED();
     }
 
     scoped_refptr<IOThreadProxy> proxy_;
   };
 
   FileSystemOperation* GetNewOperation() {
     // The FileSystemOperation takes ownership of the CallbackDispatcher.
     return new FileSystemOperation(new CallbackDispatcher(this),
-                                   io_thread_, NULL);
+                                   io_thread_, file_system_context_.get(),

[kinuko, 2011/03/22 00:16:24]

Yeah, I was thinking we should have done this.

+                                   NULL);
+
   }
 
   void DidSucceed() {
     if (!main_thread_->BelongsToCurrentThread()) {
       main_thread_->PostTask(FROM_HERE, NewRunnableMethod(
           this, &IOThreadProxy::DidSucceed));
       return;
     }
     if (simple_writer_)
       simple_writer_->DidSucceed();
@@ skipping 25 matching lines @@
   }
 
   scoped_refptr<base::MessageLoopProxy> io_thread_;
   scoped_refptr<base::MessageLoopProxy> main_thread_;
 
   // Only used on the main thread.
   base::WeakPtr<SimpleFileWriter> simple_writer_;
 
   // Only used on the io thread.
   FileSystemOperation* operation_;
+
+  scoped_refptr<FileSystemContext> file_system_context_;
 };
 
 
 SimpleFileWriter::SimpleFileWriter(
-     const WebString& path, WebFileWriterClient* client)
+    const WebString& path,
+    WebFileWriterClient* client,
+    FileSystemContext* file_system_context)
   : WebFileWriterBase(path, client),
-    io_thread_proxy_(new IOThreadProxy(AsWeakPtr())) {
+    io_thread_proxy_(new IOThreadProxy(AsWeakPtr(), file_system_context)) {
 }
 
 SimpleFileWriter::~SimpleFileWriter() {
 }
 
 void SimpleFileWriter::DoTruncate(const FilePath& path, int64 offset) {
   io_thread_proxy_->Truncate(path, offset);
 }
 
 void SimpleFileWriter::DoWrite(
     const FilePath& path, const GURL& blob_url, int64 offset) {
   io_thread_proxy_->Write(path, blob_url, offset);
 }
 
 void SimpleFileWriter::DoCancel() {
   io_thread_proxy_->Cancel();
 }