src/chrome/browser/browsing_data/browsing_data_file_system_helper.cc

   1 // Copyright (c) 2012 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/browsing_data/browsing_data_file_system_helper.h"
   6
   7 #include "base/bind.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/sequenced_task_runner.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "chrome/browser/browsing_data/browsing_data_helper.h"
  15 #include "content/public/browser/browser_thread.h"
  16 #include "webkit/browser/fileapi/file_system_context.h"
  17 #include "webkit/browser/fileapi/file_system_quota_util.h"
  18 #include "webkit/common/fileapi/file_system_types.h"
  19
  20 using content::BrowserThread;
  21
  22 namespace fileapi {
  23 class FileSystemContext;
  24 }
  25
  26 namespace {
  27
  28 // An implementation of the BrowsingDataFileSystemHelper interface that pulls
  29 // data from a given |filesystem_context| and returns a list of FileSystemInfo
  30 // items to a client.
  31 class BrowsingDataFileSystemHelperImpl : public BrowsingDataFileSystemHelper {
  32  public:
  33   // BrowsingDataFileSystemHelper implementation
  34   explicit BrowsingDataFileSystemHelperImpl(
  35       fileapi::FileSystemContext* filesystem_context);
  36   virtual void StartFetching(const base::Callback<
  37       void(const std::list<FileSystemInfo>&)>& callback) OVERRIDE;
  38   virtual void DeleteFileSystemOrigin(const GURL& origin) OVERRIDE;
  39
  40  private:
  41   virtual ~BrowsingDataFileSystemHelperImpl();
  42
  43   // Enumerates all filesystem files, storing the resulting list into
  44   // file_system_file_ for later use. This must be called on the file
  45   // task runner.
  46   void FetchFileSystemInfoInFileThread();
  47
  48   // Triggers the success callback as the end of a StartFetching workflow. This
  49   // must be called on the UI thread.
  50   void NotifyOnUIThread();
  51
  52   // Deletes all file systems associated with |origin|. This must be called on
  53   // the file task runner.
  54   void DeleteFileSystemOriginInFileThread(const GURL& origin);
  55
  56   // Returns the file task runner for the |filesystem_context_|.
  57   base::SequencedTaskRunner* file_task_runner() {
  58     return filesystem_context_->default_file_task_runner();
  59   }
  60
  61   // Keep a reference to the FileSystemContext object for the current profile
  62   // for use on the file task runner.
  63   scoped_refptr<fileapi::FileSystemContext> filesystem_context_;
  64
  65   // Holds the current list of file systems returned to the client after
  66   // StartFetching is called. Access to |file_system_info_| is triggered
  67   // indirectly via the UI thread and guarded by |is_fetching_|. This means
  68   // |file_system_info_| is only accessed while |is_fetching_| is true. The
  69   // flag |is_fetching_| is only accessed on the UI thread. In the context of
  70   // this class |file_system_info_| only mutates on the file task runner.
  71   std::list<FileSystemInfo> file_system_info_;
  72
  73   // Holds the callback passed in at the beginning of the StartFetching workflow
  74   // so that it can be triggered via NotifyOnUIThread. This only mutates on the
  75   // UI thread.
  76   base::Callback<void(const std::list<FileSystemInfo>&)> completion_callback_;
  77
  78   // Indicates whether or not we're currently fetching information: set to true
  79   // when StartFetching is called on the UI thread, and reset to false when
  80   // NotifyOnUIThread triggers the success callback.
  81   // This property only mutates on the UI thread.
  82   bool is_fetching_;
  83
  84   DISALLOW_COPY_AND_ASSIGN(BrowsingDataFileSystemHelperImpl);
  85 };
  86
  87 BrowsingDataFileSystemHelperImpl::BrowsingDataFileSystemHelperImpl(
  88     fileapi::FileSystemContext* filesystem_context)
  89     : filesystem_context_(filesystem_context),
  90       is_fetching_(false) {
  91   DCHECK(filesystem_context_.get());
  92 }
  93
  94 BrowsingDataFileSystemHelperImpl::~BrowsingDataFileSystemHelperImpl() {
  95 }
  96
  97 void BrowsingDataFileSystemHelperImpl::StartFetching(
  98     const base::Callback<void(const std::list<FileSystemInfo>&)>& callback) {
  99   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 100   DCHECK(!is_fetching_);
 101   DCHECK_EQ(false, callback.is_null());
 102   is_fetching_ = true;
 103   completion_callback_ = callback;
 104   file_task_runner()->PostTask(
 105       FROM_HERE,
 106       base::Bind(
 107           &BrowsingDataFileSystemHelperImpl::FetchFileSystemInfoInFileThread,
 108           this));
 109 }
 110
 111 void BrowsingDataFileSystemHelperImpl::DeleteFileSystemOrigin(
 112     const GURL& origin) {
 113   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 114   file_task_runner()->PostTask(
 115       FROM_HERE,
 116       base::Bind(
 117           &BrowsingDataFileSystemHelperImpl::DeleteFileSystemOriginInFileThread,
 118           this, origin));
 119 }
 120
 121 void BrowsingDataFileSystemHelperImpl::FetchFileSystemInfoInFileThread() {
 122   DCHECK(file_task_runner()->RunsTasksOnCurrentThread());
 123
 124   // We check usage for these filesystem types.
 125   const fileapi::FileSystemType types[] = {
 126     fileapi::kFileSystemTypeTemporary,
 127     fileapi::kFileSystemTypePersistent,
 128     fileapi::kFileSystemTypeSyncable,
 129   };
 130
 131   typedef std::map<GURL, FileSystemInfo> OriginInfoMap;
 132   OriginInfoMap file_system_info_map;
 133   for (size_t i = 0; i < arraysize(types); ++i) {
 134     fileapi::FileSystemType type = types[i];
 135     fileapi::FileSystemQuotaUtil* quota_util =
 136       filesystem_context_->GetQuotaUtil(type);
 137     DCHECK(quota_util);
 138     std::set<GURL> origins;
 139     quota_util->GetOriginsForTypeOnFileThread(type, &origins);
 140     for (std::set<GURL>::iterator iter = origins.begin();
 141         iter != origins.end(); ++iter) {
 142       const GURL& current = *iter;
 143       if (!BrowsingDataHelper::HasWebScheme(current))
 144         continue;  // Non-websafe state is not considered browsing data.
 145       int64 usage = quota_util->GetOriginUsageOnFileThread(
 146           filesystem_context_.get(), current, type);
 147       OriginInfoMap::iterator inserted =
 148           file_system_info_map.insert(
 149               std::make_pair(current, FileSystemInfo(current))).first;
 150       inserted->second.usage_map[type] = usage;
 151     }
 152   }
 153
 154   for (OriginInfoMap::iterator iter = file_system_info_map.begin();
 155        iter != file_system_info_map.end(); ++iter) {
 156     file_system_info_.push_back(iter->second);
 157   }
 158
 159   BrowserThread::PostTask(
 160       BrowserThread::UI, FROM_HERE,
 161       base::Bind(&BrowsingDataFileSystemHelperImpl::NotifyOnUIThread, this));
 162 }
 163
 164 void BrowsingDataFileSystemHelperImpl::NotifyOnUIThread() {
 165   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 166   DCHECK(is_fetching_);
 167   completion_callback_.Run(file_system_info_);
 168   completion_callback_.Reset();
 169   is_fetching_ = false;
 170 }
 171
 172 void BrowsingDataFileSystemHelperImpl::DeleteFileSystemOriginInFileThread(
 173     const GURL& origin) {
 174   DCHECK(file_task_runner()->RunsTasksOnCurrentThread());
 175   filesystem_context_->DeleteDataForOriginOnFileThread(origin);
 176 }
 177
 178 }  // namespace
 179
 180 BrowsingDataFileSystemHelper::FileSystemInfo::FileSystemInfo(
 181     const GURL& origin) : origin(origin) {}
 182
 183 BrowsingDataFileSystemHelper::FileSystemInfo::~FileSystemInfo() {}
 184
 185 // static
 186 BrowsingDataFileSystemHelper* BrowsingDataFileSystemHelper::Create(
 187     fileapi::FileSystemContext* filesystem_context) {
 188   return new BrowsingDataFileSystemHelperImpl(filesystem_context);
 189 }
 190
 191 CannedBrowsingDataFileSystemHelper::CannedBrowsingDataFileSystemHelper(
 192     Profile* profile)
 193     : is_fetching_(false) {
 194 }
 195
 196 CannedBrowsingDataFileSystemHelper::CannedBrowsingDataFileSystemHelper()
 197     : is_fetching_(false) {
 198 }
 199
 200 CannedBrowsingDataFileSystemHelper::~CannedBrowsingDataFileSystemHelper() {}
 201
 202 CannedBrowsingDataFileSystemHelper*
 203     CannedBrowsingDataFileSystemHelper::Clone() {
 204   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 205   CannedBrowsingDataFileSystemHelper* clone =
 206       new CannedBrowsingDataFileSystemHelper();
 207   // This list only mutates on the UI thread, so it's safe to work with it here
 208   // (given the DCHECK above).
 209   clone->file_system_info_ = file_system_info_;
 210   return clone;
 211 }
 212
 213 void CannedBrowsingDataFileSystemHelper::AddFileSystem(
 214     const GURL& origin, const fileapi::FileSystemType type, const int64 size) {
 215   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 216   // This canned implementation of AddFileSystem uses an O(n^2) algorithm; which
 217   // is fine, as it isn't meant for use in a high-volume context. If it turns
 218   // out that we want to start using this in a context with many, many origins,
 219   // we should think about reworking the implementation.
 220   bool duplicate_origin = false;
 221   for (std::list<FileSystemInfo>::iterator
 222            file_system = file_system_info_.begin();
 223        file_system != file_system_info_.end();
 224        ++file_system) {
 225     if (file_system->origin == origin) {
 226       file_system->usage_map[type] = size;
 227       duplicate_origin = true;
 228       break;
 229     }
 230   }
 231   if (duplicate_origin)
 232     return;
 233
 234   if (!BrowsingDataHelper::HasWebScheme(origin))
 235     return;  // Non-websafe state is not considered browsing data.
 236
 237   FileSystemInfo info(origin);
 238   info.usage_map[type] = size;
 239   file_system_info_.push_back(info);
 240 }
 241
 242 void CannedBrowsingDataFileSystemHelper::Reset() {
 243   file_system_info_.clear();
 244 }
 245
 246 bool CannedBrowsingDataFileSystemHelper::empty() const {
 247   return file_system_info_.empty();
 248 }
 249
 250 size_t CannedBrowsingDataFileSystemHelper::GetFileSystemCount() const {
 251   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 252   return file_system_info_.size();
 253 }
 254
 255 void CannedBrowsingDataFileSystemHelper::StartFetching(
 256     const base::Callback<void(const std::list<FileSystemInfo>&)>& callback) {
 257   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 258   DCHECK(!is_fetching_);
 259   DCHECK_EQ(false, callback.is_null());
 260   is_fetching_ = true;
 261   completion_callback_ = callback;
 262
 263   BrowserThread::PostTask(
 264       BrowserThread::UI, FROM_HERE,
 265       base::Bind(&CannedBrowsingDataFileSystemHelper::NotifyOnUIThread, this));
 266 }
 267
 268 void CannedBrowsingDataFileSystemHelper::NotifyOnUIThread() {
 269   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 270   DCHECK(is_fetching_);
 271   completion_callback_.Run(file_system_info_);
 272   completion_callback_.Reset();
 273   is_fetching_ = false;
 274 }