chrome/browser/browsing_data/browsing_data_service_worker_helper.cc

   1 // Copyright 2014 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_service_worker_helper.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "chrome/browser/browsing_data/browsing_data_helper.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #include "content/public/browser/service_worker_context.h"
  18
  19 using content::BrowserThread;
  20 using content::ServiceWorkerContext;
  21 using content::ServiceWorkerUsageInfo;
  22
  23 BrowsingDataServiceWorkerHelper::BrowsingDataServiceWorkerHelper(
  24     ServiceWorkerContext* service_worker_context)
  25     : service_worker_context_(service_worker_context), is_fetching_(false) {
  26   DCHECK(service_worker_context_);
  27 }
  28
  29 BrowsingDataServiceWorkerHelper::~BrowsingDataServiceWorkerHelper() {
  30 }
  31
  32 void BrowsingDataServiceWorkerHelper::StartFetching(const base::Callback<
  33     void(const std::list<ServiceWorkerUsageInfo>&)>& callback) {
  34   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  35   DCHECK(!is_fetching_);
  36   DCHECK(!callback.is_null());
  37
  38   is_fetching_ = true;
  39   completion_callback_ = callback;
  40   BrowserThread::PostTask(BrowserThread::IO,
  41                           FROM_HERE,
  42                           base::Bind(&BrowsingDataServiceWorkerHelper::
  43                                          FetchServiceWorkerUsageInfoOnIOThread,
  44                                      this));
  45 }
  46
  47 void BrowsingDataServiceWorkerHelper::DeleteServiceWorkers(const GURL& origin) {
  48   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  49   BrowserThread::PostTask(
  50       BrowserThread::IO,
  51       FROM_HERE,
  52       base::Bind(
  53           &BrowsingDataServiceWorkerHelper::DeleteServiceWorkersOnIOThread,
  54           this,
  55           origin));
  56 }
  57
  58 void BrowsingDataServiceWorkerHelper::FetchServiceWorkerUsageInfoOnIOThread() {
  59   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  60
  61   service_worker_context_->GetAllOriginsInfo(base::Bind(
  62       &BrowsingDataServiceWorkerHelper::GetAllOriginsInfoCallback, this));
  63 }
  64
  65 void BrowsingDataServiceWorkerHelper::GetAllOriginsInfoCallback(
  66     const std::vector<ServiceWorkerUsageInfo>& origins) {
  67   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  68   for (std::vector<ServiceWorkerUsageInfo>::const_iterator iter =
  69            origins.begin();
  70        iter != origins.end();
  71        ++iter) {
  72     const ServiceWorkerUsageInfo& origin = *iter;
  73     if (!BrowsingDataHelper::HasWebScheme(origin.origin))
  74       continue;  // Non-websafe state is not considered browsing data.
  75
  76     service_worker_info_.push_back(origin);
  77   }
  78
  79   BrowserThread::PostTask(
  80       BrowserThread::UI,
  81       FROM_HERE,
  82       base::Bind(&BrowsingDataServiceWorkerHelper::NotifyOnUIThread, this));
  83 }
  84
  85 void BrowsingDataServiceWorkerHelper::NotifyOnUIThread() {
  86   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  87   DCHECK(is_fetching_);
  88   completion_callback_.Run(service_worker_info_);
  89   completion_callback_.Reset();
  90   is_fetching_ = false;
  91 }
  92
  93 void BrowsingDataServiceWorkerHelper::DeleteServiceWorkersOnIOThread(
  94     const GURL& origin) {
  95   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  96   service_worker_context_->DeleteForOrigin(origin);
  97 }
  98
  99 CannedBrowsingDataServiceWorkerHelper::PendingServiceWorkerUsageInfo::
 100     PendingServiceWorkerUsageInfo(const GURL& origin,
 101                                   const std::vector<GURL>& scopes)
 102     : origin(origin), scopes(scopes) {
 103 }
 104
 105 CannedBrowsingDataServiceWorkerHelper::PendingServiceWorkerUsageInfo::
 106     ~PendingServiceWorkerUsageInfo() {
 107 }
 108
 109 bool CannedBrowsingDataServiceWorkerHelper::PendingServiceWorkerUsageInfo::
 110 operator<(const PendingServiceWorkerUsageInfo& other) const {
 111   if (origin == other.origin)
 112     return scopes < other.scopes;
 113   return origin < other.origin;
 114 }
 115
 116 CannedBrowsingDataServiceWorkerHelper::CannedBrowsingDataServiceWorkerHelper(
 117     content::ServiceWorkerContext* context)
 118     : BrowsingDataServiceWorkerHelper(context) {
 119 }
 120
 121 CannedBrowsingDataServiceWorkerHelper::
 122     ~CannedBrowsingDataServiceWorkerHelper() {
 123 }
 124
 125 void CannedBrowsingDataServiceWorkerHelper::AddServiceWorker(
 126     const GURL& origin, const std::vector<GURL>& scopes) {
 127   if (!BrowsingDataHelper::HasWebScheme(origin))
 128     return;  // Non-websafe state is not considered browsing data.
 129
 130   pending_service_worker_info_.insert(
 131       PendingServiceWorkerUsageInfo(origin, scopes));
 132 }
 133
 134 void CannedBrowsingDataServiceWorkerHelper::Reset() {
 135   service_worker_info_.clear();
 136   pending_service_worker_info_.clear();
 137 }
 138
 139 bool CannedBrowsingDataServiceWorkerHelper::empty() const {
 140   return service_worker_info_.empty() && pending_service_worker_info_.empty();
 141 }
 142
 143 size_t CannedBrowsingDataServiceWorkerHelper::GetServiceWorkerCount() const {
 144   return pending_service_worker_info_.size();
 145 }
 146
 147 const std::set<
 148     CannedBrowsingDataServiceWorkerHelper::PendingServiceWorkerUsageInfo>&
 149 CannedBrowsingDataServiceWorkerHelper::GetServiceWorkerUsageInfo() const {
 150   return pending_service_worker_info_;
 151 }
 152
 153 void CannedBrowsingDataServiceWorkerHelper::StartFetching(const base::Callback<
 154     void(const std::list<ServiceWorkerUsageInfo>&)>& callback) {
 155   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 156   DCHECK(!callback.is_null());
 157
 158   std::list<ServiceWorkerUsageInfo> result;
 159   for (std::set<PendingServiceWorkerUsageInfo>::const_iterator pending_info =
 160            pending_service_worker_info_.begin();
 161        pending_info != pending_service_worker_info_.end();
 162        ++pending_info) {
 163     ServiceWorkerUsageInfo info(
 164         pending_info->origin, pending_info->scopes);
 165     result.push_back(info);
 166   }
 167
 168   BrowserThread::PostTask(
 169       BrowserThread::UI, FROM_HERE, base::Bind(callback, result));
 170 }
 171
 172 void CannedBrowsingDataServiceWorkerHelper::DeleteServiceWorkers(
 173     const GURL& origin) {
 174   for (std::set<PendingServiceWorkerUsageInfo>::iterator it =
 175            pending_service_worker_info_.begin();
 176        it != pending_service_worker_info_.end();) {
 177     if (it->origin == origin)
 178       pending_service_worker_info_.erase(it++);
 179     else
 180       ++it;
 181   }
 182   BrowsingDataServiceWorkerHelper::DeleteServiceWorkers(origin);
 183 }