Add a debug check to verify that FileSystemCallbackDispatcher is not NULL in FileSystemOperation.

webkit/fileapi/file_system_operation.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/fileapi/file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
@@ skipping 62 matching lines @@
 FileSystemOperation::~FileSystemOperation() {
   if (file_writer_delegate_.get())
     FileSystemFileUtilProxy::Close(
         operation_context_, proxy_, file_writer_delegate_->file(),
         FileSystemFileUtilProxy::StatusCallback());
 }
 
 void FileSystemOperation::OpenFileSystem(
     const GURL& origin_url, fileapi::FileSystemType type, bool create) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);

[kinuko, 2011/10/26 12:09:26]

s/dispatcher/dispatcher_/ here and everywhere?

[Oleg Eterevsky, 2011/10/26 12:19:24]

Sorry, my bad. I've send the CL before waiting for it to compile. Fixed.

   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = static_cast<FileSystemOperation::OperationType>(
       kOperationOpenFileSystem);
 #endif
 
   DCHECK(file_system_context());
   operation_context_.set_src_origin_url(origin_url);
   operation_context_.set_src_type(type);
   // TODO(ericu): We don't really need to make this call if !create.
   // Also, in the future we won't need it either way, as long as we do all
   // permission+quota checks beforehand.  We only need it now because we have to
   // create an unpredictable directory name.  Without that, we could lazily
   // create the root later on the first filesystem write operation, and just
   // return GetFileSystemRootURI() here.
   file_system_context()->path_manager()->ValidateFileSystemRootAndGetURL(
       origin_url, type, create,
       base::Bind(&FileSystemOperation::DidGetRootPath,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::CreateFile(const GURL& path,
                                      bool exclusive) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateFile;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
   exclusive_ = exclusive;
 
   GetUsageAndQuotaThenCallback(
@@ skipping 18 matching lines @@
       base::Bind(
           exclusive_ ? &FileSystemOperation::DidEnsureFileExistsExclusive
                      : &FileSystemOperation::DidEnsureFileExistsNonExclusive,
           weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::CreateDirectory(const GURL& path,
                                           bool exclusive,
                                           bool recursive) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateDirectory;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
   exclusive_ = exclusive;
   recursive_ = recursive;
 
@@ skipping 15 matching lines @@
   FileSystemFileUtilProxy::CreateDirectory(
       operation_context_, proxy_, src_virtual_path_, exclusive_,
       recursive_,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::Copy(const GURL& src_path,
                                const GURL& dest_path) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCopy;
 #endif
   if (!SetupSrcContextForRead(src_path) ||
       !SetupDestContextForWrite(dest_path, true)) {
     delete this;
     return;
   }
 
   GetUsageAndQuotaThenCallback(
@@ skipping 14 matching lines @@
   FileSystemFileUtilProxy::Copy(
       operation_context_, proxy_, src_virtual_path_,
       dest_virtual_path_,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::Move(const GURL& src_path,
                                const GURL& dest_path) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationMove;
 #endif
   if (!SetupSrcContextForWrite(src_path, false) ||
       !SetupDestContextForWrite(dest_path, true)) {
     delete this;
     return;
   }
 
   GetUsageAndQuotaThenCallback(
@@ skipping 13 matching lines @@
 
   FileSystemFileUtilProxy::Move(
       operation_context_, proxy_, src_virtual_path_,
       dest_virtual_path_,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::DirectoryExists(const GURL& path) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationDirectoryExists;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
       operation_context_, proxy_, src_virtual_path_,
       base::Bind(&FileSystemOperation::DidDirectoryExists,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::FileExists(const GURL& path) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationFileExists;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
       operation_context_, proxy_, src_virtual_path_,
       base::Bind(&FileSystemOperation::DidFileExists,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::GetMetadata(const GURL& path) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationGetMetadata;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
       operation_context_, proxy_, src_virtual_path_,
       base::Bind(&FileSystemOperation::DidGetMetadata,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::ReadDirectory(const GURL& path) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationReadDirectory;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::ReadDirectory(
       operation_context_, proxy_, src_virtual_path_,
       base::Bind(&FileSystemOperation::DidReadDirectory,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::Remove(const GURL& path, bool recursive) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationRemove;
 #endif
   if (!SetupSrcContextForWrite(path, false)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::Delete(
       operation_context_, proxy_, src_virtual_path_, recursive,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::Write(
     scoped_refptr<net::URLRequestContext> url_request_context,
     const GURL& path,
     const GURL& blob_url,
     int64 offset) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationWrite;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(this, offset, proxy_));
   blob_request_.reset(
@@ skipping 20 matching lines @@
       proxy_,
       src_virtual_path_,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
           base::PLATFORM_FILE_ASYNC,
       base::Bind(&FileSystemOperation::OnFileOpenedForWrite,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::Truncate(const GURL& path, int64 length) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTruncate;
 #endif
   if (!SetupSrcContextForWrite(path, false)) {
     delete this;
     return;
   }
   length_ = length;
 
   GetUsageAndQuotaThenCallback(
@@ skipping 14 matching lines @@
   FileSystemFileUtilProxy::Truncate(
       operation_context_, proxy_, src_virtual_path_, length_,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::TouchFile(const GURL& path,
                                     const base::Time& last_access_time,
                                     const base::Time& last_modified_time) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTouchFile;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::Touch(
       operation_context_, proxy_, src_virtual_path_,
       last_access_time, last_modified_time,
       base::Bind(&FileSystemOperation::DidTouchFile,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::OpenFile(const GURL& path,
                                    int file_flags,
                                    base::ProcessHandle peer_handle) {
 #ifndef NDEBUG
+  DCHECK(dispatcher);
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationOpenFile;
 #endif
   peer_handle_ = peer_handle;
 
   if (file_flags & (
       (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
        base::PLATFORM_FILE_HIDDEN))) {
     delete this;
     return;
@@ skipping 394 matching lines @@
   bool result = VerifyFileSystemPathForWrite(
       path, create, &origin_url, &type, &dest_virtual_path_, &file_util);
   operation_context_.set_dest_origin_url(origin_url);
   operation_context_.set_dest_type(type);
   if (!operation_context_.dest_file_util())
     operation_context_.set_dest_file_util(file_util);
   return result;
 }
 
 }  // namespace fileapi