Separate memory purger from safe browsing.

chrome/browser/safe_browsing/safe_browsing_service.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/safe_browsing/safe_browsing_service.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/malware_details.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/notification_service.h"
 #include "net/base/registry_controlled_domain.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_WIN)
 #include "chrome/installer/util/browser_distribution.h"
 #endif
 
 namespace {
 
 // The default URL prefix where browser fetches chunk updates, hashes,
@@ skipping 421 matching lines @@
   else
     ShutDown();
 }
 
 // static
 void SafeBrowsingService::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kSafeBrowsingClientKey, "");
   prefs->RegisterStringPref(prefs::kSafeBrowsingWrappedKey, "");
 }
 
-void SafeBrowsingService::CloseDatabase() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  // Cases to avoid:
-  //  * If |closing_database_| is true, continuing will queue up a second
-  //    request, |closing_database_| will be reset after handling the first
-  //    request, and if any functions on the db thread recreate the database, we
-  //    could start using it on the IO thread and then have the second request
-  //    handler delete it out from under us.
-  //  * If |database_| is NULL, then either no creation request is in flight, in
-  //    which case we don't need to do anything, or one is in flight, in which
-  //    case the database will be recreated before our deletion request is
-  //    handled, and could be used on the IO thread in that time period, leading
-  //    to the same problem as above.
-  //  * If |queued_checks_| is non-empty and |database_| is non-NULL, we're
-  //    about to be called back (in DatabaseLoadComplete()).  This will call
-  //    CheckUrl(), which will want the database.  Closing the database here
-  //    would lead to an infinite loop in DatabaseLoadComplete(), and even if it
-  //    didn't, it would be pointless since we'd just want to recreate.
-  //
-  // The first two cases above are handled by checking DatabaseAvailable().
-  if (!DatabaseAvailable() || !queued_checks_.empty())
-    return;
-
-  closing_database_ = true;
-  if (safe_browsing_thread_.get()) {
-    safe_browsing_thread_->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &SafeBrowsingService::OnCloseDatabase));
-  }
-}
-
 void SafeBrowsingService::ResetDatabase() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SafeBrowsingService::OnResetDatabase));
 }
 
 void SafeBrowsingService::LogPauseDelay(base::TimeDelta time) {
   UMA_HISTOGRAM_LONG_TIMES("SB2.Delay", time);
 }
 
 SafeBrowsingService::~SafeBrowsingService() {
   // We should have already been shut down.  If we're still enabled, then the
   // database isn't going to be closed properly, which could lead to corruption.
   DCHECK(!enabled_);
 }
 
 void SafeBrowsingService::OnIOInitialize(
     const std::string& client_key,
     const std::string& wrapped_key,
     net::URLRequestContextGetter* request_context_getter) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   enabled_ = true;
 
+  registrar_.Add(this, NotificationType::PURGE_MEMORY,
+                 NotificationService::AllSources());
+
   MakeDatabaseAvailable();
 
   // On Windows, get the safe browsing client name from the browser
   // distribution classes in installer util. These classes don't yet have
   // an analog on non-Windows builds so just keep the name specified here.
 #if defined(OS_WIN)
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::string client_name(dist->GetSafeBrowsingName());
 #else
 #if defined(GOOGLE_CHROME_BUILD)
@@ skipping 29 matching lines @@
   protocol_manager_->Initialize();
 }
 
 void SafeBrowsingService::OnIOShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!enabled_)
     return;
 
   enabled_ = false;
 
+  registrar_.RemoveAll();
+
   // This cancels all in-flight GetHash requests.
   delete protocol_manager_;
   protocol_manager_ = NULL;
 
   // Delete queued checks, calling back any clients with 'SAFE'.
   // If we don't do this here we may fail to close the database below.
   while (!queued_checks_.empty()) {
     QueuedCheck queued = queued_checks_.front();
     if (queued.client) {
       SafeBrowsingCheck sb_check;
@@ skipping 50 matching lines @@
 bool SafeBrowsingService::MakeDatabaseAvailable() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   if (DatabaseAvailable())
     return true;
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &SafeBrowsingService::GetDatabase));
   return false;
 }
 
+void SafeBrowsingService::CloseDatabase() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Cases to avoid:
+  //  * If |closing_database_| is true, continuing will queue up a second
+  //    request, |closing_database_| will be reset after handling the first
+  //    request, and if any functions on the db thread recreate the database, we
+  //    could start using it on the IO thread and then have the second request
+  //    handler delete it out from under us.
+  //  * If |database_| is NULL, then either no creation request is in flight, in
+  //    which case we don't need to do anything, or one is in flight, in which
+  //    case the database will be recreated before our deletion request is
+  //    handled, and could be used on the IO thread in that time period, leading
+  //    to the same problem as above.
+  //  * If |queued_checks_| is non-empty and |database_| is non-NULL, we're
+  //    about to be called back (in DatabaseLoadComplete()).  This will call
+  //    CheckUrl(), which will want the database.  Closing the database here
+  //    would lead to an infinite loop in DatabaseLoadComplete(), and even if it
+  //    didn't, it would be pointless since we'd just want to recreate.
+  //
+  // The first two cases above are handled by checking DatabaseAvailable().
+  if (!DatabaseAvailable() || !queued_checks_.empty())
+    return;
+
+  closing_database_ = true;
+  if (safe_browsing_thread_.get()) {
+    safe_browsing_thread_->message_loop()->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &SafeBrowsingService::OnCloseDatabase));
+  }
+}
+
 SafeBrowsingDatabase* SafeBrowsingService::GetDatabase() {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   if (database_)
     return database_;
 
   FilePath path;
   bool result = PathService::Get(chrome::DIR_USER_DATA, &path);
   DCHECK(result);
   path = path.Append(chrome::kSafeBrowsingBaseFilename);
 
@@ skipping 540 matching lines @@
   // Whitelist this domain and warning type for the given tab.
   WhiteListedEntry entry;
   entry.render_process_host_id = resource.render_process_host_id;
   entry.render_view_id = resource.render_view_id;
   entry.domain = net::RegistryControlledDomainService::GetDomainAndRegistry(
       resource.url);
   entry.result = resource.threat_type;
   white_listed_entries_.push_back(entry);
 }
 
+void SafeBrowsingService::Observe(NotificationType type,
+                                  const NotificationSource& source,
+                                  const NotificationDetails& details) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(type == NotificationType::PURGE_MEMORY);
+  CloseDatabase();
+}
+
 bool SafeBrowsingService::IsWhitelisted(const UnsafeResource& resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Check if the user has already ignored our warning for this render_view
   // and domain.
   for (size_t i = 0; i < white_listed_entries_.size(); ++i) {
     const WhiteListedEntry& entry = white_listed_entries_[i];
     if (entry.render_process_host_id == resource.render_process_host_id &&
         entry.render_view_id == resource.render_view_id &&
         // Threat type must be the same or in the case of phishing they can
         // either be client-side phishing URL or a SafeBrowsing phishing URL.
         // If we show one type of phishing warning we don't want to show a
         // second phishing warning.
         (entry.result == resource.threat_type ||
          (entry.result == URL_PHISHING &&
           resource.threat_type == CLIENT_SIDE_PHISHING_URL) ||
          (entry.result == CLIENT_SIDE_PHISHING_URL &&
           resource.threat_type == URL_PHISHING))  &&
         entry.domain ==
         net::RegistryControlledDomainService::GetDomainAndRegistry(
             resource.url)) {
       return true;
     }
   }
   return false;
 }