Remove NOTIFICATION_SYSTEM_SETTING_CHANGED, switch CrosSettings to base::CallbackRegistry.

chrome/browser/chromeos/policy/device_status_collector.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/chromeos/policy/device_status_collector.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_source.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using base::Time;
 using base::TimeDelta;
 using chromeos::VersionLoader;
 
 namespace em = enterprise_management;
 
 namespace {
 // How many seconds of inactivity triggers the idle state.
@@ skipping 99 matching lines @@
         base::Bind(&Context::GetLocationUpdate, context_.get());
   }
   idle_poll_timer_.Start(FROM_HERE,
                          TimeDelta::FromSeconds(kIdlePollIntervalSeconds),
                          this, &DeviceStatusCollector::CheckIdleState);
 
   cros_settings_ = chromeos::CrosSettings::Get();
 
   // Watch for changes to the individual policies that control what the status
   // reports contain.
-  cros_settings_->AddSettingsObserver(chromeos::kReportDeviceVersionInfo, this);
-  cros_settings_->AddSettingsObserver(chromeos::kReportDeviceActivityTimes,
-                                      this);
-  cros_settings_->AddSettingsObserver(chromeos::kReportDeviceBootMode, this);
-  cros_settings_->AddSettingsObserver(chromeos::kReportDeviceLocation, this);
-  cros_settings_->AddSettingsObserver(chromeos::kReportDeviceNetworkInterfaces,
-                                      this);
+  base::Closure callback =
+      base::Bind(&DeviceStatusCollector::UpdateReportingSettings,
+                 base::Unretained(this));
+  version_info_subscription_ = cros_settings_->AddSettingsObserver(
+      chromeos::kReportDeviceVersionInfo, callback);
+  activity_times_subscription_ = cros_settings_->AddSettingsObserver(
+      chromeos::kReportDeviceActivityTimes, callback);
+  boot_mode_subscription_ = cros_settings_->AddSettingsObserver(
+      chromeos::kReportDeviceBootMode, callback);
+  location_subscription_ = cros_settings_->AddSettingsObserver(
+      chromeos::kReportDeviceLocation, callback);
+  network_interfaces_subscription_ = cros_settings_->AddSettingsObserver(
+      chromeos::kReportDeviceNetworkInterfaces, callback);
 
   // The last known location is persisted in local state. This makes location
   // information available immediately upon startup and avoids the need to
   // reacquire the location on every user session change or browser crash.
   content::Geoposition position;
   std::string timestamp_str;
   int64 timestamp;
   const base::DictionaryValue* location =
       local_state_->GetDictionary(prefs::kDeviceLocation);
   if (location->GetDouble(kLatitude, &position.latitude) &&
@@ skipping 16 matching lines @@
   version_loader_.GetVersion(
       VersionLoader::VERSION_FULL,
       base::Bind(&DeviceStatusCollector::OnOSVersion, base::Unretained(this)),
       &tracker_);
   version_loader_.GetFirmware(
       base::Bind(&DeviceStatusCollector::OnOSFirmware, base::Unretained(this)),
       &tracker_);
 }
 
 DeviceStatusCollector::~DeviceStatusCollector() {
-  cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceVersionInfo,
-                                         this);
-  cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceActivityTimes,
-                                         this);
-  cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceBootMode, this);
-  cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceLocation, this);
-  cros_settings_->RemoveSettingsObserver(
-      chromeos::kReportDeviceNetworkInterfaces, this);
 }
 
 // static
 void DeviceStatusCollector::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kDeviceActivityTimes,
                                    new base::DictionaryValue);
   registry->RegisterDictionaryPref(prefs::kDeviceLocation,
                                    new base::DictionaryValue);
 }
 
@@ skipping 280 matching lines @@
 }
 
 void DeviceStatusCollector::OnOSVersion(const std::string& version) {
   os_version_ = version;
 }
 
 void DeviceStatusCollector::OnOSFirmware(const std::string& version) {
   firmware_version_ = version;
 }
 
-void DeviceStatusCollector::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  if (type == chrome::NOTIFICATION_SYSTEM_SETTING_CHANGED)
-    UpdateReportingSettings();
-  else
-    NOTREACHED();
-}
-
 void DeviceStatusCollector::ScheduleGeolocationUpdateRequest() {
   if (geolocation_update_timer_.IsRunning() || geolocation_update_in_progress_)
     return;
 
   if (position_.Validate()) {
     TimeDelta elapsed = GetCurrentTime() - position_.timestamp;
     TimeDelta interval =
         TimeDelta::FromSeconds(kGeolocationPollIntervalSeconds);
     if (elapsed > interval) {
       geolocation_update_in_progress_ = true;
@@ skipping 35 matching lines @@
     location.SetDouble(kSpeed, position.speed);
     location.SetString(kTimestamp,
         base::Int64ToString(position.timestamp.ToInternalValue()));
     local_state_->Set(prefs::kDeviceLocation, location);
   }
 
   ScheduleGeolocationUpdateRequest();
 }
 
 }  // namespace policy