Make FileSystemOperation's lifetime more explicit.

webkit/tools/test_shell/simple_file_system.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 "webkit/tools/test_shell/simple_file_system.h"
 
 #include "base/file_path.h"
 #include "base/message_loop_proxy.h"
 #include "base/scoped_callback_factory.h"
 #include "base/time.h"
@@ skipping 36 matching lines @@
     : public FileSystemCallbackDispatcher {
  public:
   SimpleFileSystemCallbackDispatcher(
       const WeakPtr<SimpleFileSystem>& file_system,
       WebFileSystemCallbacks* callbacks)
       : file_system_(file_system),
         callbacks_(callbacks) {
   }
 
   ~SimpleFileSystemCallbackDispatcher() {
-    DCHECK(!operation_.get());
-  }
-
-  void set_operation(SandboxedFileSystemOperation* operation) {
-    operation_.reset(operation);
   }
 
   virtual void DidSucceed() {
     if (file_system_)
       callbacks_->didSucceed();
-    RemoveOperation();
   }
 
   virtual void DidReadMetadata(const base::PlatformFileInfo& info) {
     if (file_system_) {
       WebFileInfo web_file_info;
       web_file_info.length = info.size;
       web_file_info.modificationTime = info.last_modified.ToDoubleT();
       web_file_info.type = info.is_directory ?
           WebFileInfo::TypeDirectory : WebFileInfo::TypeFile;
       callbacks_->didReadMetadata(web_file_info);
     }
-    RemoveOperation();
   }
 
   virtual void DidReadDirectory(
       const std::vector<base::FileUtilProxy::Entry>& entries,
       bool has_more) {
     if (file_system_) {
       std::vector<WebFileSystemEntry> web_entries_vector;
       for (std::vector<base::FileUtilProxy::Entry>::const_iterator it =
               entries.begin(); it != entries.end(); ++it) {
         WebFileSystemEntry entry;
         entry.name = webkit_glue::FilePathStringToWebString(it->name);
         entry.isDirectory = it->is_directory;
         web_entries_vector.push_back(entry);
       }
       WebVector<WebKit::WebFileSystemEntry> web_entries =
           web_entries_vector;
       callbacks_->didReadDirectory(web_entries, has_more);
     }
-    RemoveOperation();
   }
 
   virtual void DidOpenFileSystem(
       const std::string& name, const FilePath& path) {
     if (file_system_) {
       if (path.empty())
         callbacks_->didFail(WebKit::WebFileErrorSecurity);
       else
         callbacks_->didOpenFileSystem(
             UTF8ToUTF16(name), webkit_glue::FilePathToWebString(path));
     }
-    RemoveOperation();
   }
 
   virtual void DidFail(base::PlatformFileError error_code) {
     if (file_system_)
       callbacks_->didFail(
           webkit_glue::PlatformFileErrorToWebFileError(error_code));
-    RemoveOperation();
   }
 
   virtual void DidWrite(int64, bool) {
     NOTREACHED();
   }
 
  private:
-  void RemoveOperation() {
-    // We need to make sure operation_ is null when we delete the operation
-    // (which in turn deletes this dispatcher instance).
-    scoped_ptr<SandboxedFileSystemOperation> operation;
-    operation.swap(operation_);
-    operation.reset();
-  }
-
   WeakPtr<SimpleFileSystem> file_system_;
   WebFileSystemCallbacks* callbacks_;
-  scoped_ptr<SandboxedFileSystemOperation> operation_;
 };
 
 }  // namespace
 
 SimpleFileSystem::SimpleFileSystem() {
   if (file_system_dir_.CreateUniqueTempDir()) {
     sandboxed_context_.reset(new SandboxedFileSystemContext(
         base::MessageLoopProxy::CreateForCurrentThread(),
         file_system_dir_.path(),
         false /* incognito */,
@@ skipping 112 matching lines @@
   return new SimpleFileWriter(path, client);
 }
 
 SandboxedFileSystemOperation* SimpleFileSystem::GetNewOperation(
     WebFileSystemCallbacks* callbacks) {
   SimpleFileSystemCallbackDispatcher* dispatcher =
       new SimpleFileSystemCallbackDispatcher(AsWeakPtr(), callbacks);
   SandboxedFileSystemOperation* operation = new SandboxedFileSystemOperation(
       dispatcher, base::MessageLoopProxy::CreateForCurrentThread(),
       sandboxed_context_.get());
-  dispatcher->set_operation(operation);
   return operation;
 }