chrome/browser/chromeos/drive/debug_info_collector.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/drive/debug_info_collector.h"
   6
   7 #include "base/callback.h"
   8 #include "base/logging.h"
   9 #include "content/public/browser/browser_thread.h"
  10 #include "google_apis/drive/task_util.h"
  11
  12 using content::BrowserThread;
  13
  14 namespace drive {
  15
  16 namespace {
  17
  18 void IterateFileCacheInternal(
  19     internal::FileCache* file_cache,
  20     const DebugInfoCollector::IterateFileCacheCallback& iteration_callback) {
  21   scoped_ptr<internal::FileCache::Iterator> it = file_cache->GetIterator();
  22   for (; !it->IsAtEnd(); it->Advance())
  23     iteration_callback.Run(it->GetID(), it->GetValue());
  24   DCHECK(!it->HasError());
  25 }
  26
  27 // Runs the callback with arguments.
  28 void RunGetResourceEntryCallback(const GetResourceEntryCallback& callback,
  29                                  scoped_ptr<ResourceEntry> entry,
  30                                  FileError error) {
  31   DCHECK(!callback.is_null());
  32   if (error != FILE_ERROR_OK)
  33     entry.reset();
  34   callback.Run(error, entry.Pass());
  35 }
  36
  37 // Runs the callback with arguments.
  38 void RunReadDirectoryCallback(
  39     const DebugInfoCollector::ReadDirectoryCallback& callback,
  40     scoped_ptr<ResourceEntryVector> entries,
  41     FileError error) {
  42   DCHECK(!callback.is_null());
  43   if (error != FILE_ERROR_OK)
  44     entries.reset();
  45   callback.Run(error, entries.Pass());
  46 }
  47
  48 }  // namespace
  49
  50 DebugInfoCollector::DebugInfoCollector(
  51     internal::FileCache* file_cache,
  52     internal::ResourceMetadata* metadata,
  53     FileSystemInterface* file_system,
  54     base::SequencedTaskRunner* blocking_task_runner)
  55     : file_cache_(file_cache),
  56       metadata_(metadata),
  57       file_system_(file_system),
  58       blocking_task_runner_(blocking_task_runner) {
  59   DCHECK(file_cache_);
  60   DCHECK(metadata_);
  61   DCHECK(file_system_);
  62 }
  63
  64 DebugInfoCollector::~DebugInfoCollector() {
  65 }
  66
  67 void DebugInfoCollector::GetResourceEntry(
  68     const base::FilePath& file_path,
  69     const GetResourceEntryCallback& callback) {
  70   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  71   DCHECK(!callback.is_null());
  72
  73   scoped_ptr<ResourceEntry> entry(new ResourceEntry);
  74   ResourceEntry* entry_ptr = entry.get();
  75   base::PostTaskAndReplyWithResult(
  76       blocking_task_runner_,
  77       FROM_HERE,
  78       base::Bind(&internal::ResourceMetadata::GetResourceEntryByPath,
  79                  base::Unretained(metadata_),
  80                  file_path,
  81                  entry_ptr),
  82       base::Bind(&RunGetResourceEntryCallback, callback, base::Passed(&entry)));
  83 }
  84
  85 void DebugInfoCollector::ReadDirectory(
  86     const base::FilePath& file_path,
  87     const ReadDirectoryCallback& callback) {
  88   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  89   DCHECK(!callback.is_null());
  90
  91   scoped_ptr<ResourceEntryVector> entries(new ResourceEntryVector);
  92   ResourceEntryVector* entries_ptr = entries.get();
  93   base::PostTaskAndReplyWithResult(
  94       blocking_task_runner_.get(),
  95       FROM_HERE,
  96       base::Bind(&internal::ResourceMetadata::ReadDirectoryByPath,
  97                  base::Unretained(metadata_),
  98                  file_path,
  99                  entries_ptr),
 100       base::Bind(&RunReadDirectoryCallback, callback, base::Passed(&entries)));
 101 }
 102
 103 void DebugInfoCollector::IterateFileCache(
 104     const IterateFileCacheCallback& iteration_callback,
 105     const base::Closure& completion_callback) {
 106   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 107   DCHECK(!iteration_callback.is_null());
 108   DCHECK(!completion_callback.is_null());
 109
 110   blocking_task_runner_->PostTaskAndReply(
 111       FROM_HERE,
 112       base::Bind(&IterateFileCacheInternal,
 113                  file_cache_,
 114                  google_apis::CreateRelayCallback(iteration_callback)),
 115       completion_callback);
 116 }
 117
 118 void DebugInfoCollector::GetMetadata(
 119     const GetFilesystemMetadataCallback& callback) {
 120   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 121   DCHECK(!callback.is_null());
 122
 123   // Currently, this is just a proxy to the FileSystem.
 124   // TODO(hidehiko): Move the implementation to here to simplify the
 125   // FileSystem's implementation. crbug.com/237088
 126   file_system_->GetMetadata(callback);
 127 }
 128
 129 }  // namespace drive