Add trace to the caller of QuotaManager::GetAvailableSpace

storage/browser/fileapi/file_system_operation_impl.cc

 // Copyright 2013 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 "storage/browser/fileapi/file_system_operation_impl.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "base/trace_event/trace_event.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/async_file_util.h"
 #include "storage/browser/fileapi/copy_or_move_operation_delegate.h"
 #include "storage/browser/fileapi/file_observers.h"
 #include "storage/browser/fileapi/file_system_backend.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_file_util.h"
 #include "storage/browser/fileapi/remove_operation_delegate.h"
@@ skipping 35 matching lines @@
   return new FileSystemOperationImpl(url, file_system_context,
                                      operation_context.Pass());
 }
 
 FileSystemOperationImpl::~FileSystemOperationImpl() {
 }
 
 void FileSystemOperationImpl::CreateFile(const FileSystemURL& url,
                                          bool exclusive,
                                          const StatusCallback& callback) {
+  // crbug.com/349708
+  TRACE_EVENT0("io", "FileSystemOperationImpl::CreateFile");
+
   DCHECK(SetPendingOperationType(kOperationCreateFile));
+
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoCreateFile,
                  weak_factory_.GetWeakPtr(), url, callback, exclusive),
       base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::CreateDirectory(const FileSystemURL& url,
                                               bool exclusive,
                                               bool recursive,
                                               const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateDirectory));
+
+  // crbug.com/349708
+  TRACE_EVENT0("io", "FileSystemOperationImpl::CreateDirectory");
+
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoCreateDirectory,
                  weak_factory_.GetWeakPtr(), url, callback,
                  exclusive, recursive),
       base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::Copy(
     const FileSystemURL& src_url,
@@ skipping 94 matching lines @@
   file_writer_delegate_ = writer_delegate.Pass();
   file_writer_delegate_->Start(
       blob_request.Pass(),
       base::Bind(&FileSystemOperationImpl::DidWrite,
                  weak_factory_.GetWeakPtr(), url, callback));
 }
 
 void FileSystemOperationImpl::Truncate(const FileSystemURL& url, int64 length,
                                        const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
+
+  // crbug.com/349708
+  TRACE_EVENT0("io", "FileSystemOperationImpl::Truncate");
+
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoTruncate,
                  weak_factory_.GetWeakPtr(), url, callback, length),
       base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::TouchFile(const FileSystemURL& url,
                                         const base::Time& last_access_time,
                                         const base::Time& last_modified_time,
                                         const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTouchFile));
+
+  // crbug.com/349708
+  TRACE_EVENT0("io", "FileSystemOperationImpl::TouchFile");
+
   async_file_util_->Touch(
       operation_context_.Pass(), url,
       last_access_time, last_modified_time,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::OpenFile(const FileSystemURL& url,
                                        int file_flags,
                                        const OpenFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationOpenFile));
 
   if (file_flags &
       (base::File::FLAG_TEMPORARY | base::File::FLAG_HIDDEN)) {
     callback.Run(base::File(base::File::FILE_ERROR_FAILED),
                  base::Closure());
     return;
   }
+
+  // crbug.com/349708
+  TRACE_EVENT0("io", "FileSystemOperationImpl::OpenFile");
+
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoOpenFile,
                  weak_factory_.GetWeakPtr(),
                  url, callback, file_flags),
       base::Bind(callback, Passed(base::File(base::File::FILE_ERROR_FAILED)),
                  base::Closure()));
 }
 
 // We can only get here on a write or truncate that's not yet completed.
@@ skipping 22 matching lines @@
   DCHECK(SetPendingOperationType(kOperationCreateSnapshotFile));
   async_file_util_->CreateSnapshotFile(
       operation_context_.Pass(), url, callback);
 }
 
 void FileSystemOperationImpl::CopyInForeignFile(
     const base::FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopyInForeignFile));
+
+  // crbug.com/349708
+  TRACE_EVENT0("io", "FileSystemOperationImpl::CopyInForeinFile");
+
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&FileSystemOperationImpl::DoCopyInForeignFile,
                  weak_factory_.GetWeakPtr(), src_local_disk_file_path, dest_url,
                  callback),
       base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::RemoveFile(
     const FileSystemURL& url,
@@ skipping 17 matching lines @@
 
 void FileSystemOperationImpl::CopyFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const CopyFileProgressCallback& progress_callback,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopy));
   DCHECK(src_url.IsInSameFileSystem(dest_url));
 
+  // crbug.com/349708
+  TRACE_EVENT0("io", "FileSystemOperationImpl::CopyFileLocal");
+
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&FileSystemOperationImpl::DoCopyFileLocal,
                  weak_factory_.GetWeakPtr(), src_url, dest_url, option,
                  progress_callback, callback),
       base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::MoveFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationMove));
   DCHECK(src_url.IsInSameFileSystem(dest_url));
+
+  // crbug.com/349708
+  TRACE_EVENT0("io", "FileSystemOperationImpl::MoveFileLocal");
+
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&FileSystemOperationImpl::DoMoveFileLocal,
                  weak_factory_.GetWeakPtr(),
                  src_url, dest_url, option, callback),
       base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 base::File::Error FileSystemOperationImpl::SyncGetPlatformPath(
     const FileSystemURL& url,
@@ skipping 228 matching lines @@
 }
 
 bool FileSystemOperationImpl::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace storage