Added ability to propogate create to suggest whether or not filesystem's root...

chrome/browser/file_system/file_system_dispatcher_host.cc

 // Copyright (c) 2010 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 "chrome/browser/file_system/file_system_dispatcher_host.h"
 
 #include "base/file_path.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 13 matching lines @@
 #include "webkit/fileapi/file_system_quota.h"
 
 using fileapi::FileSystemQuota;
 
 class FileSystemDispatcherHost::OpenFileSystemTask {
  public:
   static void Start(
       int request_id,
       const GURL& origin_url,
       fileapi::FileSystemType type,
+      bool create,
       FileSystemDispatcherHost* dispatcher_host) {
     // The task is self-destructed.
-    new OpenFileSystemTask(request_id, origin_url, type, dispatcher_host);
+    new OpenFileSystemTask(
+        request_id, origin_url, type, create, dispatcher_host);
   }
 
  private:
   void DidGetRootPath(bool success, const FilePath& root_path,
                       const std::string& name) {
     if (success)
       dispatcher_host_->Send(
           new ViewMsg_OpenFileSystemRequest_Complete(
               request_id_, true, name, root_path));
     else
       dispatcher_host_->Send(
           new ViewMsg_OpenFileSystemRequest_Complete(
               request_id_, false, std::string(), FilePath()));
     delete this;
   }
 
   OpenFileSystemTask(
       int request_id,
       const GURL& origin_url,
       fileapi::FileSystemType type,
+      bool create,
       FileSystemDispatcherHost* dispatcher_host)
     : request_id_(request_id),
       dispatcher_host_(dispatcher_host),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     dispatcher_host->context_->path_manager()->GetFileSystemRootPath(
-        origin_url, type, true /* create */,
+        origin_url, type, create,
         callback_factory_.NewCallback(&OpenFileSystemTask::DidGetRootPath));
   }
 
   int request_id_;
   std::string name_;
   FilePath root_path_;
   scoped_refptr<FileSystemDispatcherHost> dispatcher_host_;
   base::ScopedCallbackFactory<OpenFileSystemTask> callback_factory_;
 };
 
@@ skipping 58 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_FileSystem_Truncate, OnTruncate)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FileSystem_TouchFile, OnTouchFile)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FileSystem_CancelWrite, OnCancel)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 void FileSystemDispatcherHost::OnOpenFileSystem(
     int request_id, const GURL& origin_url, fileapi::FileSystemType type,
-    int64 requested_size) {
+    int64 requested_size, bool create) {
   ContentSetting content_setting =
       host_content_settings_map_->GetContentSetting(
           origin_url, CONTENT_SETTINGS_TYPE_COOKIES, "");
   DCHECK((content_setting == CONTENT_SETTING_ALLOW) ||
          (content_setting == CONTENT_SETTING_BLOCK) ||
          (content_setting == CONTENT_SETTING_SESSION_ONLY));
   if (content_setting == CONTENT_SETTING_BLOCK) {
     // TODO(kinuko): Need to notify the UI thread to indicate that
     // there's a blocked content.
     Send(new ViewMsg_OpenFileSystemRequest_Complete(
         request_id, false, std::string(), FilePath()));
     return;
   }
 
-  OpenFileSystemTask::Start(request_id, origin_url, type, this);
+  OpenFileSystemTask::Start(request_id, origin_url, type, create, this);
 }
 
 void FileSystemDispatcherHost::OnMove(
     int request_id, const FilePath& src_path, const FilePath& dest_path) {
   if (!VerifyFileSystemPathForRead(src_path, request_id) ||
       !VerifyFileSystemPathForWrite(dest_path, request_id, true /* create */,
                                     FileSystemQuota::kUnknownSize))
     return;
 
   GetNewOperation(request_id)->Move(src_path, dest_path);
@@ skipping 171 matching lines @@
       dispatcher,
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   operations_.AddWithID(operation, request_id);
   return operation;
 }
 
 void FileSystemDispatcherHost::RemoveCompletedOperation(int request_id) {
   DCHECK(operations_.Lookup(request_id));
   operations_.Remove(request_id);
 }