Change webkit/{fileapi,quota} code to use TaskRunner.

webkit/fileapi/file_system_context.h

 // 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.
 
 #ifndef WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/quota/special_storage_policy.h"
 
 class FilePath;
 class GURL;
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
+class SequencedTaskRunner;

[michaeln, 2012/04/27 22:31:08]

nit(picky-nit): alpha ordering

[kinuko, 2012/05/04 19:05:35]

Done.

 }
 
 namespace quota {
 class QuotaManagerProxy;
 }
 
 namespace webkit_blob {
 class FileReader;
 }
 
@@ skipping 10 matching lines @@
 class SandboxMountPointProvider;
 
 struct DefaultContextDeleter;
 
 // This class keeps and provides a file system context for FileSystem API.
 // An instance of this class is created and owned by profile.
 class FileSystemContext
     : public base::RefCountedThreadSafe<FileSystemContext,
                                         DefaultContextDeleter> {
  public:
+  // |file_task_runner| is used for all file operations and file related
+  // meta operations.
+  // The code assumes that file_task_runner->RunsTasksOnCurrentThread() returns
+  // false if the current task is not running on the thread that allows

[michaeln, 2012/04/27 22:31:08]

fyi: the semantics/implemetation of RunsTasksOnCurrentThread across the various
impls of TaskRunner is squisher than the old CurrentlyOn() semantics we've been
using against our set of well-known-threads.

The abstract TaskRunner specs this method in a very squishy way...
  // Returns true if the current thread is a thread on which a task
  // may be run, and false if no task will be run on the current
  // thread.
  //
  // It is valid for an implementation to always return true, or in
  // general to use 'true' as a default value.
  virtual bool RunsTasksOnCurrentThread() const = 0;


The SequencedTaskRunner derivatives have impls that are more useful than that.
The impl
backed by a message loop functions just like the old CurrentlyOn() stuff. The
impl backed
by SWP (SequencedWorkerPoolSequencedTaskRunner) is written in terms of
SWP::IsRunningSequenceOnCurrentThread() which is a close approximation of
CurrentlyOn(), but not quite the same thing...

For example, owned/refcounted object held by a Bind closure may be
deleted/finallyReleased immediately after having executed a task on the SWP (on
the same thread as having executed that task). During task execution,
RunsTasksOnCurrentThread() will return true, but during Bind closure cleanup, it
will return false (since  that closure cleanup is outside of execution of the
task).

Just pointing these subtleties out so you know what you getting into, and aren't
totally surprised when things work slightly differently when you start passing
in an instance of SequencedWorkerPoolSequencedTaskRunner to the
FileSystemContext ctor as the file_task_runner.

[kinuko, 2012/05/04 19:05:35]

Yes, I had read this comment and how they are implemented in SWP / STP backed by
MessageLoopProxy since I wasn't comfortable replacing them without looking into
the actual code.
Thanks, the actual example helps me understand.  I'm expecting
SWP::RunsCurrentTasksOnCurrentThread() could behave differently from what 
BelongsToCurrentThread() used to, but such subtleties may still surprise me :)

+  // blocking file operations (like SequencedWorkerPool implementation does).
   FileSystemContext(
-      scoped_refptr<base::MessageLoopProxy> file_message_loop,
-      scoped_refptr<base::MessageLoopProxy> io_message_loop,
-      scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy,
+      base::SequencedTaskRunner* file_task_runner,
+      base::SingleThreadTaskRunner* io_task_runner,
+      quota::SpecialStoragePolicy* special_storage_policy,
       quota::QuotaManagerProxy* quota_manager_proxy,
       const FilePath& profile_path,
       const FileSystemOptions& options);
   ~FileSystemContext();
 
   // This method can be called on any thread.

[michaeln, 2012/04/27 22:31:08]

Is this this comment correct? DCHECKs in the method bodies suggest otherwise?

[ericu, 2012/05/01 00:30:35]

It used to go with IsStorageUnlimited, and should have been deleted when that
went away.

[kinuko, 2012/05/04 19:05:35]

Done.

   bool DeleteDataForOriginOnFileThread(const GURL& origin_url);
   bool DeleteDataForOriginAndTypeOnFileThread(const GURL& origin_url,
                                               FileSystemType type);
 
   quota::QuotaManagerProxy* quota_manager_proxy() const {
     return quota_manager_proxy_.get();
   }
 
   // Returns a quota util for a given filesystem type.  This may
   // return NULL if the type does not support the usage tracking or
@@ skipping 35 matching lines @@
       const GURL& origin_url,
       FileSystemType type,
       bool create,
       OpenFileSystemCallback callback);
 
   // Creates a new FileSystemOperation instance by cracking
   // the given filesystem URL |url| to get an appropriate MountPointProvider
   // and calling the provider's corresponding CreateFileSystemOperation method.
   // The resolved MountPointProvider could perform further specialization
   // depending on the filesystem type pointed by the |url|.
-  FileSystemOperationInterface* CreateFileSystemOperation(
-      const GURL& url,
-      base::MessageLoopProxy* file_proxy);
+  FileSystemOperationInterface* CreateFileSystemOperation(const GURL& url);
 
   // Creates new FileReader instance to read a file pointed by the given
   // filesystem URL |url| starting from |offset|.
   // This method internally cracks the |url|, get an appropriate
   // MountPointProvider for the URL and call the provider's CreateFileReader.
   // The resolved MountPointProvider could perform further specialization
   // depending on the filesystem type pointed by the |url|.
   webkit_blob::FileReader* CreateFileReader(
       const GURL& url,
-      int64 offset,
-      base::MessageLoopProxy* file_proxy);
+      int64 offset);
 
  private:
   friend struct DefaultContextDeleter;
   void DeleteOnCorrectThread() const;
 
-  scoped_refptr<base::MessageLoopProxy> file_message_loop_;
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
 
   // Mount point providers.
   scoped_ptr<SandboxMountPointProvider> sandbox_provider_;
   scoped_ptr<IsolatedMountPointProvider> isolated_provider_;
   scoped_ptr<ExternalFileSystemMountPointProvider> external_provider_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileSystemContext);
 };
 
 struct DefaultContextDeleter {
   static void Destruct(const FileSystemContext* context) {
     context->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_