Link PasswordProtectionService to Profile and SB Service

chrome/browser/safe_browsing/safe_browsing_service.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/safe_browsing/chrome_password_protection_service.h"
 #include "chrome/browser/safe_browsing/ping_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_navigation_observer_manager.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/file_type_policies.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing/common/safebrowsing_constants.h"
 #include "components/safe_browsing/common/safebrowsing_switches.h"
-#include "components/safe_browsing/password_protection/password_protection_service.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/v4_feature_list.h"
 #include "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 #include "components/safe_browsing_db/v4_local_database_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_request_info.h"
 #include "google_apis/google_api_keys.h"
 #include "net/cookies/cookie_store.h"
@@ skipping 273 matching lines @@
   }
 
   if (base::FeatureList::IsEnabled(
     SafeBrowsingNavigationObserverManager::kDownloadAttribution)) {
     navigation_observer_manager_ = new SafeBrowsingNavigationObserverManager();
   }
 
   services_delegate_->Initialize(v4_enabled_);
   services_delegate_->InitializeCsdService(url_request_context_getter_.get());
 
-  // TODO(jialiul): When PasswordProtectionService does more than reporting UMA,
-  // we need to add finch trial to gate its functionality.
-  password_protection_service_ = base::MakeUnique<PasswordProtectionService>(
-      database_manager(), url_request_context());
-
-  // Track the safe browsing preference of existing profiles.
-  // The SafeBrowsingService will be started if any existing profile has the
-  // preference enabled. It will also listen for updates to the preferences.
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  if (profile_manager) {
-    std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
-    // TODO(felt): I believe this for-loop is dead code. Confirm this and
-    // remove in a future CL. See https://codereview.chromium.org/1341533002/
-    DCHECK_EQ(0u, profiles.size());
-    for (size_t i = 0; i < profiles.size(); ++i) {
-      if (profiles[i]->IsOffTheRecord())
-        continue;
-      AddPrefService(profiles[i]->GetPrefs());
-    }
-  }
-
   // Track profile creation and destruction.
-  prefs_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
-                       content::NotificationService::AllSources());
-  prefs_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
-                       content::NotificationService::AllSources());
+  profiles_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
+                          content::NotificationService::AllSources());
+  profiles_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
+                          content::NotificationService::AllSources());
 
   // Register all the delayed analysis to the incident reporting service.
   RegisterAllDelayedAnalysis();
 }
 
 void SafeBrowsingService::ShutDown() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   shutdown_callback_list_.Notify();
 
   // Delete the PrefChangeRegistrars, whose dtors also unregister |this| as an
   // observer of the preferences.
   prefs_map_.clear();
 
+  // Delete the ChromePasswordProtectionService instances.
+  password_protection_service_map_.clear();
+
   // Remove Profile creation/destruction observers.
-  prefs_registrar_.RemoveAll();
+  profiles_registrar_.RemoveAll();
 
   Stop(true);
 
-  password_protection_service_.reset();
-
   services_delegate_->ShutdownServices();
 
   // Since URLRequestContextGetters are refcounted, can't count on clearing
   // |url_request_context_getter_| to delete it, so need to shut it down first,
   // which will cancel any requests that are currently using it, and prevent
   // new requests from using it as well.
   BrowserThread::PostNonNestableTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingURLRequestContextGetter::ServiceShuttingDown,
                  url_request_context_getter_));
@@ skipping 57 matching lines @@
 SafeBrowsingPingManager* SafeBrowsingService::ping_manager() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return ping_manager_.get();
 }
 
 const scoped_refptr<SafeBrowsingDatabaseManager>&
 SafeBrowsingService::v4_local_database_manager() const {
   return services_delegate_->v4_local_database_manager();
 }
 
-PasswordProtectionService* SafeBrowsingService::password_protection_service() {
-  return password_protection_service_.get();
+PasswordProtectionService* SafeBrowsingService::GetPasswordProtectionService(
+    Profile* profile) {
+  DCHECK(profile);
+  auto it = password_protection_service_map_.find(profile);
+  DCHECK(it != password_protection_service_map_.end());
+  return it->second.get();
 }
 
 std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate>
 SafeBrowsingService::CreatePreferenceValidationDelegate(
     Profile* profile) const {
   return services_delegate_->CreatePreferenceValidationDelegate(profile);
 }
 
 void SafeBrowsingService::RegisterDelayedAnalysisCallback(
     const DelayedAnalysisCallback& callback) {
@@ skipping 181 matching lines @@
       base::Bind(&SafeBrowsingService::StopOnIOThread, this, shutdown));
 }
 
 void SafeBrowsingService::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_CREATED: {
       DCHECK_CURRENTLY_ON(BrowserThread::UI);
       Profile* profile = content::Source<Profile>(source).ptr();
+      CreatePasswordProtectionService(profile);
       if (!profile->IsOffTheRecord())
         AddPrefService(profile->GetPrefs());
       break;
     }
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       DCHECK_CURRENTLY_ON(BrowserThread::UI);
       Profile* profile = content::Source<Profile>(source).ptr();
+      RemovePasswordProtectionService(profile);
       if (!profile->IsOffTheRecord())
         RemovePrefService(profile->GetPrefs());
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void SafeBrowsingService::AddPrefService(PrefService* pref_service) {
@@ skipping 90 matching lines @@
   if (ping_manager())
     ping_manager()->ReportThreatDetails(report);
 }
 
 void SafeBrowsingService::ProcessResourceRequest(
     const ResourceRequestInfo& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   services_delegate_->ProcessResourceRequest(&request);
 }
 
+void SafeBrowsingService::CreatePasswordProtectionService(Profile* profile) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(profile);
+  auto it = password_protection_service_map_.find(profile);
+  // Return early if there is already a ChromePasswordProtectionService instance
+  // created for this profile.
+  if (it != password_protection_service_map_.end() && it->second)

[Nathan Parker, 2017/03/30 21:38:12]

should this be an error?

[Jialiu Lin, 2017/03/30 23:23:05]

Right, it is impossible to create the same profile twice. Change to DCHECK

+    return;
+
+  std::unique_ptr<ChromePasswordProtectionService> service =
+      base::MakeUnique<ChromePasswordProtectionService>(this, profile);
+  password_protection_service_map_[profile] = std::move(service);
+}
+
+void SafeBrowsingService::RemovePasswordProtectionService(Profile* profile) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(profile);
+  auto it = password_protection_service_map_.find(profile);
+  if (it != password_protection_service_map_.end())
+    password_protection_service_map_.erase(it);

[Nathan Parker, 2017/03/30 21:38:12]

Also, maybe an error if it's not there. Could be a dcheck.

[Jialiu Lin, 2017/03/30 23:23:05]

Done.

+}
+
 }  // namespace safe_browsing