BrowsingDataRemover: Getting ChromeAppCacheService directly from Profile.

chrome/browser/browsing_data_remover.cc

 // Copyright (c) 2011 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 "chrome/browser/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 
 #include "base/callback.h"
@@ skipping 48 matching lines @@
                                          base::Time delete_begin,
                                          base::Time delete_end)
     : profile_(profile),
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(delete_begin),
       delete_end_(delete_end),
       ALLOW_THIS_IN_INITIALIZER_LIST(database_cleared_callback_(
           this, &BrowsingDataRemover::OnClearedDatabases)),
       ALLOW_THIS_IN_INITIALIZER_LIST(cache_callback_(
           this, &BrowsingDataRemover::DoClearCache)),
+      appcache_service_(profile->GetAppCacheService()),
       ALLOW_THIS_IN_INITIALIZER_LIST(appcache_got_info_callback_(
           this, &BrowsingDataRemover::OnGotAppCacheInfo)),
       ALLOW_THIS_IN_INITIALIZER_LIST(appcache_deleted_callback_(
           this, &BrowsingDataRemover::OnAppCacheDeleted)),
       appcaches_to_be_deleted_count_(0),
       next_cache_state_(STATE_NONE),
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetRequestContextForMedia()),
       waiting_for_clear_databases_(false),
@@ skipping 138 matching lines @@
     database_tracker_ = profile_->GetDatabaseTracker();
     if (database_tracker_.get()) {
       waiting_for_clear_databases_ = true;
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           NewRunnableMethod(
               this,
               &BrowsingDataRemover::ClearDatabasesOnFILEThread));
     }
 
     waiting_for_clear_appcache_ = true;

[willchan no longer on Chromium, 2011/07/03 09:11:21]

Awesome! I was going to do this cleanup too. Glad to see you did the work for me
already. One thing I had done in my local changelist was mimic database_tracker_
above, where I don't post the task if appcache_service_ is NULL. I think that's
a minor improvement, so I thought I'd point it out. If you're busy, then no big
deal. Thanks for killing off that reinterpret_cast.

[marja(google), 2011/07/06 09:40:01]

I created another changelist for that http://codereview.chromium.org/7311001/ (I
guess that was what you meant?) Thanks for the feedback.

     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(
             this,
             &BrowsingDataRemover::ClearAppCacheOnIOThread));
 
     waiting_for_clear_gears_data_ = true;
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(
@@ skipping 281 matching lines @@
     return;
   }
   waiting_for_clear_appcache_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearAppCacheOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(waiting_for_clear_appcache_);
   appcache_info_ = new appcache::AppCacheInfoCollection;
-  if (GetAppCacheService()) {
-    GetAppCacheService()->GetAllAppCacheInfo(
+  if (appcache_service_) {
+    appcache_service_->GetAllAppCacheInfo(
         appcache_info_, &appcache_got_info_callback_);
     // continues in OnGotAppCacheInfo
   } else {
     // Couldn't get app cache service, nothing to clear.
     OnClearedAppCache();
   }
 }
 
 void BrowsingDataRemover::OnGotAppCacheInfo(int rv) {
   using appcache::AppCacheInfoVector;
   typedef std::map<GURL, AppCacheInfoVector> InfoByOrigin;
 
   for (InfoByOrigin::const_iterator origin =
            appcache_info_->infos_by_origin.begin();
        origin != appcache_info_->infos_by_origin.end(); ++origin) {
     if (special_storage_policy_->IsStorageProtected(origin->first))
       continue;
     for (AppCacheInfoVector::const_iterator info = origin->second.begin();
          info != origin->second.end(); ++info) {
       if (info->creation_time > delete_begin_) {
         ++appcaches_to_be_deleted_count_;
-        GetAppCacheService()->DeleteAppCacheGroup(
+        appcache_service_->DeleteAppCacheGroup(
             info->manifest_url, &appcache_deleted_callback_);
       }
     }
   }
 
   if (!appcaches_to_be_deleted_count_)
     OnClearedAppCache();
   // else continues in OnAppCacheDeleted
 }
 
 void BrowsingDataRemover::OnAppCacheDeleted(int rv) {
   --appcaches_to_be_deleted_count_;
   if (!appcaches_to_be_deleted_count_)
     OnClearedAppCache();
 }
 
-ChromeAppCacheService* BrowsingDataRemover::GetAppCacheService() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ChromeURLRequestContext* request_context = NULL;
-  if (main_context_getter_)
-    request_context = reinterpret_cast<ChromeURLRequestContext*>(
-        main_context_getter_->GetURLRequestContext());
-  return request_context ? request_context->appcache_service()
-                         : NULL;
-}
-
 void BrowsingDataRemover::ClearFileSystemsOnFILEThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(waiting_for_clear_file_systems_);
   scoped_refptr<fileapi::FileSystemContext>
       fs_context(profile_->GetFileSystemContext());
   scoped_ptr<fileapi::SandboxMountPointProvider::OriginEnumerator>
       origin_enumerator(fs_context->path_manager()->sandbox_provider()->
           CreateOriginEnumerator());
 
   GURL origin;
@@ skipping 48 matching lines @@
 
   ClearGearsData(profile_dir);
   OnClearedGearsData();
 }
 
 void BrowsingDataRemover::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
   waiting_for_clear_lso_data_ = false;
   NotifyAndDeleteIfDone();
 }