AppCaches which belong to hosted apps are not protected from deletion

chrome/browser/profiles/profile_impl.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/profiles/profile_impl.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/synchronization/waitable_event.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/background/background_contents_service_factory.h"
 #include "chrome/browser/background/background_mode_manager.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_signin.h"
 #include "chrome/browser/browsing_data_remover.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
@@ skipping 555 matching lines @@
 void ProfileImpl::set_last_selected_directory(const FilePath& path) {
   GetPrefs()->SetFilePath(prefs::kSelectFileLastDirectory, path);
 }
 
 ProfileImpl::~ProfileImpl() {
   NotificationService::current()->Notify(
       NotificationType::PROFILE_DESTROYED,
       Source<Profile>(this),
       NotificationService::NoDetails());
 
+  if (appcache_service_ && prefs_->GetBoolean(prefs::kClearSiteDataOnExit)) {
+    // We don't own event
+    base::WaitableEvent* event = appcache_service_->ClearAppCache(NULL);
+    event->Wait();

[michaeln, 2011/07/02 00:29:09]

We should not block the UI thread for this as profiles can be deleted at times
other than shutdown.

I think a decent place to wait for completion would be in the vicinity of the
call to WaitForPluginDataRemoverToFinish() in ~BrowserProcessImpl(). The trick
is figuring out what to wait on exactly. 

We might be able to generalize this a bit. The code below is not correct since
it creates complex objects as statics (the WaitableEvent), but i'm just trying
to get across the general idea here. If this existed i imagine
WaitForPluginDataRemoverToFinish() could be implemented in terms of this class
too. For ChromeAppCacheService to utilize a class like this it would have to be
in the /content layer.

class PreventBrowserShutdown {
 public:
  // Created by classes like the ChromeAppCacheService prior to starting
  // its 'clearonexit' work, and then deleted by the ChromeAppCacheService when
  // that work is done.
  PreventBrowserShutdown();
  ~PreventBrowserShutdown();

  // Called by ~BrowserProcessImpl to wait for all instances to be
  // deleted prior to tearing down the background threads.
  static void Wait(int timeout_milliseconds);

 private:
  static base::AtomicRefCount instance_count_;
  static WaitableEvent event_;
};

PreventBrowserShutdown::PreventBrowserShutdown() {
  AtomicRefCountInc(&instance_count_);
  event_.Reset();
}

PreventBrowserShutdown::~PreventBrowserShutdown() {
  if (!AtomicRefCountDec(&instance_count_))
    event_.Signal();
}

void PreventBrowserShutdown::Wait(int timeout_millis) {
  // We can assume that no new instances will be created after
  // the time that this method is invoked.
  if (AtomicRefCountIsZero(&instance_count_))
    return;
  event_.TimedWait(timeout_millis);
}

[jochen (gone - plz use gerrit), 2011/07/06 09:41:45]

I agree that we shouldn't wait on the UI thread. OTOH, why wait for the deletion
to complete? 

At this point, we can be sure that the IO thread will be drained before the
browser shuts down, so we can just fire the task to the IO thread and forget
about it

[marja(google), 2011/07/06 11:44:39]

The appcache deletion procedure posts tasks across the IO and DB threads (so, a
task is posted to the IO thread, when that is executed, it posts a task to the
DB thread, when that is executed, it posts again to the IO thread, etc.) So it
could happen that there are no tasks in the IO thread, so the IO thread can shut
down, and when the task in the DB thread is executed, it's too late to post
anything to the IO thread any more. Or am I missing something?

+  }
+
   StopCreateSessionServiceTimer();
 
   // Remove pref observers
   pref_change_registrar_.RemoveAll();
 
   ProfileDependencyManager::GetInstance()->DestroyProfileServices(this);
 
   if (clear_local_state_on_exit_) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
@@ skipping 713 matching lines @@
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::WEBKIT));
   appcache_service_ = new ChromeAppCacheService(quota_manager_->proxy());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           appcache_service_.get(),
           &ChromeAppCacheService::InitializeOnIOThread,
           IsOffTheRecord()
               ? FilePath() : GetPath().Append(chrome::kAppCacheDirname),
           &GetResourceContext(),
-          make_scoped_refptr(GetExtensionSpecialStoragePolicy()),
-          clear_local_state_on_exit_));
+          make_scoped_refptr(GetExtensionSpecialStoragePolicy())));
 }
 
 WebKitContext* ProfileImpl::GetWebKitContext() {
   CreateQuotaManagerAndClients();
   return webkit_context_.get();
 }
 
 void ProfileImpl::MarkAsCleanShutdown() {
   if (prefs_.get()) {
     // The session cleanly exited, set kSessionExitedCleanly appropriately.
@@ skipping 33 matching lines @@
           RenderProcessHost* process = i.GetCurrentValue();
           process->Send(new SpellCheckMsg_EnableAutoSpellCorrect(enabled));
         }
       } else if (*pref_name_in == prefs::kClearSiteDataOnExit) {
         clear_local_state_on_exit_ =
             prefs->GetBoolean(prefs::kClearSiteDataOnExit);
         if (webkit_context_) {
           webkit_context_->set_clear_local_state_on_exit(
               clear_local_state_on_exit_);
         }
-        if (appcache_service_) {
-          appcache_service_->SetClearLocalStateOnExit(
-              clear_local_state_on_exit_);
-        }
       } else if (*pref_name_in == prefs::kGoogleServicesUsername) {
         ProfileManager* profile_manager = g_browser_process->profile_manager();
         profile_manager->RegisterProfileName(this);
       } else if (*pref_name_in == prefs::kDefaultZoomLevel) {
           GetHostZoomMap()->set_default_zoom_level(
               prefs->GetDouble(prefs::kDefaultZoomLevel));
       }
       break;
     }
     case NotificationType::BOOKMARK_MODEL_LOADED:
@@ skipping 238 matching lines @@
   if (!prerender::PrerenderManager::IsPrerenderingPossible())
     return NULL;
   if (!prerender_manager_.get()) {
     CHECK(g_browser_process->prerender_tracker());
     prerender_manager_.reset(
         new prerender::PrerenderManager(
             this, g_browser_process->prerender_tracker()));
   }
   return prerender_manager_.get();
 }