Home | History | Annotate | Download | only in drive 
      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::ResourceMetadata* metadata,
     20     const DebugInfoCollector::IterateFileCacheCallback& iteration_callback) {
     21   scoped_ptr<internal::ResourceMetadata::Iterator> it = metadata->GetIterator();
     22   for (; !it->IsAtEnd(); it->Advance()) {
     23     if (it->GetValue().file_specific_info().has_cache_state()) {
     24       iteration_callback.Run(it->GetID(),
     25                              it->GetValue().file_specific_info().cache_state());
     26     }
     27   }
     28   DCHECK(!it->HasError());
     29 }
     30 
     31 // Runs the callback with arguments.
     32 void RunGetResourceEntryCallback(const GetResourceEntryCallback& callback,
     33                                  scoped_ptr<ResourceEntry> entry,
     34                                  FileError error) {
     35   DCHECK(!callback.is_null());
     36   if (error != FILE_ERROR_OK)
     37     entry.reset();
     38   callback.Run(error, entry.Pass());
     39 }
     40 
     41 // Runs the callback with arguments.
     42 void RunReadDirectoryCallback(
     43     const DebugInfoCollector::ReadDirectoryCallback& callback,
     44     scoped_ptr<ResourceEntryVector> entries,
     45     FileError error) {
     46   DCHECK(!callback.is_null());
     47   if (error != FILE_ERROR_OK)
     48     entries.reset();
     49   callback.Run(error, entries.Pass());
     50 }
     51 
     52 }  // namespace
     53 
     54 DebugInfoCollector::DebugInfoCollector(
     55     internal::ResourceMetadata* metadata,
     56     FileSystemInterface* file_system,
     57     base::SequencedTaskRunner* blocking_task_runner)
     58     : metadata_(metadata),
     59       file_system_(file_system),
     60       blocking_task_runner_(blocking_task_runner) {
     61   DCHECK(metadata_);
     62   DCHECK(file_system_);
     63 }
     64 
     65 DebugInfoCollector::~DebugInfoCollector() {
     66 }
     67 
     68 void DebugInfoCollector::GetResourceEntry(
     69     const base::FilePath& file_path,
     70     const GetResourceEntryCallback& callback) {
     71   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     72   DCHECK(!callback.is_null());
     73 
     74   scoped_ptr<ResourceEntry> entry(new ResourceEntry);
     75   ResourceEntry* entry_ptr = entry.get();
     76   base::PostTaskAndReplyWithResult(
     77       blocking_task_runner_.get(),
     78       FROM_HERE,
     79       base::Bind(&internal::ResourceMetadata::GetResourceEntryByPath,
     80                  base::Unretained(metadata_),
     81                  file_path,
     82                  entry_ptr),
     83       base::Bind(&RunGetResourceEntryCallback, callback, base::Passed(&entry)));
     84 }
     85 
     86 void DebugInfoCollector::ReadDirectory(
     87     const base::FilePath& file_path,
     88     const ReadDirectoryCallback& callback) {
     89   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     90   DCHECK(!callback.is_null());
     91 
     92   scoped_ptr<ResourceEntryVector> entries(new ResourceEntryVector);
     93   ResourceEntryVector* entries_ptr = entries.get();
     94   base::PostTaskAndReplyWithResult(
     95       blocking_task_runner_.get(),
     96       FROM_HERE,
     97       base::Bind(&internal::ResourceMetadata::ReadDirectoryByPath,
     98                  base::Unretained(metadata_),
     99                  file_path,
    100                  entries_ptr),
    101       base::Bind(&RunReadDirectoryCallback, callback, base::Passed(&entries)));
    102 }
    103 
    104 void DebugInfoCollector::IterateFileCache(
    105     const IterateFileCacheCallback& iteration_callback,
    106     const base::Closure& completion_callback) {
    107   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    108   DCHECK(!iteration_callback.is_null());
    109   DCHECK(!completion_callback.is_null());
    110 
    111   blocking_task_runner_->PostTaskAndReply(
    112       FROM_HERE,
    113       base::Bind(&IterateFileCacheInternal,
    114                  metadata_,
    115                  google_apis::CreateRelayCallback(iteration_callback)),
    116       completion_callback);
    117 }
    118 
    119 void DebugInfoCollector::GetMetadata(
    120     const GetFilesystemMetadataCallback& callback) {
    121   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    122   DCHECK(!callback.is_null());
    123 
    124   // Currently, this is just a proxy to the FileSystem.
    125   // TODO(hidehiko): Move the implementation to here to simplify the
    126   // FileSystem's implementation. crbug.com/237088
    127   file_system_->GetMetadata(callback);
    128 }
    129 
    130 }  // namespace drive
    131