Fix PrivetNotificationService::PrivetNotify() silliness.

chrome/browser/printing/cloud_print/privet_notifications.cc

 // Copyright 2013 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/printing/cloud_print/privet_notifications.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 73 matching lines @@
   privet_http_factory_.swap(privet_http_factory);
 }
 
 PrivetNotificationsListener::~PrivetNotificationsListener() {
 }
 
 void PrivetNotificationsListener::DeviceChanged(
     const std::string& name,
     const DeviceDescription& description) {
   ReportPrivetUmaEvent(PRIVET_DEVICE_CHANGED);
-  DeviceContextMap::iterator found = devices_seen_.find(name);
-  if (found != devices_seen_.end()) {
+  DeviceContextMap::iterator it = devices_seen_.find(name);
+  if (it != devices_seen_.end()) {
     if (!description.id.empty() &&  // Device is registered
-        found->second->notification_may_be_active) {
-      found->second->notification_may_be_active = false;
+        it->second->notification_may_be_active) {
+      it->second->notification_may_be_active = false;
+      devices_active_--;
       NotifyDeviceRemoved();
     }
     return;  // Already saw this device.
   }
 
   std::unique_ptr<DeviceContext>& device_context = devices_seen_[name];
   device_context.reset(new DeviceContext);
   device_context->notification_may_be_active = false;
   device_context->registered = !description.id.empty();
 
-  if (!device_context->registered) {
-    device_context->privet_http_resolution =
-        privet_http_factory_->CreatePrivetHTTP(name);
-    device_context->privet_http_resolution->Start(
-        description.address,
-        base::Bind(&PrivetNotificationsListener::CreateInfoOperation,
-                   base::Unretained(this)));
-  }
+  if (device_context->registered)
+    return;
+
+  device_context->privet_http_resolution =
+      privet_http_factory_->CreatePrivetHTTP(name);
+  device_context->privet_http_resolution->Start(
+      description.address,
+      base::Bind(&PrivetNotificationsListener::CreateInfoOperation,
+                 base::Unretained(this)));
 }
 
 void PrivetNotificationsListener::CreateInfoOperation(
     std::unique_ptr<PrivetHTTPClient> http_client) {
-  if (!http_client) {
-    // Do nothing if resolution fails.
+  // Do nothing if resolution fails.
+  if (!http_client)
     return;
-  }
 
   std::string name = http_client->GetName();
-  DeviceContextMap::iterator device_iter = devices_seen_.find(name);
-  if (device_iter == devices_seen_.end())
+  DeviceContextMap::iterator it = devices_seen_.find(name);
+  if (it == devices_seen_.end())
     return;
-  DeviceContext* device = device_iter->second.get();
+
+  DeviceContext* device = it->second.get();
   device->privet_http.swap(http_client);
   device->info_operation = device->privet_http->CreateInfoOperation(
       base::Bind(&PrivetNotificationsListener::OnPrivetInfoDone,
                  base::Unretained(this),
                  device));
   device->info_operation->Start();
 }
 
 void PrivetNotificationsListener::OnPrivetInfoDone(
     DeviceContext* device,
     const base::DictionaryValue* json_value) {
   int uptime;
 
   if (!json_value ||
       !json_value->GetInteger(kPrivetInfoKeyUptime, &uptime) ||
       uptime > kTenMinutesInSeconds) {
     return;
   }
 
   DCHECK(!device->notification_may_be_active);
   device->notification_may_be_active = true;
   devices_active_++;
   delegate_->PrivetNotify(devices_active_, true);
 }
 
 void PrivetNotificationsListener::DeviceRemoved(const std::string& name) {
-  DeviceContextMap::iterator device_iter = devices_seen_.find(name);
-  if (device_iter == devices_seen_.end())
+  DeviceContextMap::iterator it = devices_seen_.find(name);
+  if (it == devices_seen_.end())
     return;
-  DeviceContext* device = device_iter->second.get();
 
+  DeviceContext* device = it->second.get();
   device->info_operation.reset();
   device->privet_http_resolution.reset();
+  if (!device->notification_may_be_active)
+    return;
+
   device->notification_may_be_active = false;
+  devices_active_--;
   NotifyDeviceRemoved();
 }
 
 void PrivetNotificationsListener::DeviceCacheFlushed() {
-  for (DeviceContextMap::iterator i = devices_seen_.begin();
-       i != devices_seen_.end(); ++i) {
-    DeviceContext* device = i->second.get();
-
+  for (const auto& it : devices_seen_) {
+    DeviceContext* device = it.second.get();
     device->info_operation.reset();
     device->privet_http_resolution.reset();
-    if (device->notification_may_be_active) {
-      device->notification_may_be_active = false;
-    }
+    device->notification_may_be_active = false;
   }
 
   devices_active_ = 0;
-  delegate_->PrivetRemoveNotification();
+  NotifyDeviceRemoved();
 }
 
 void PrivetNotificationsListener::NotifyDeviceRemoved() {
-  devices_active_--;
   if (devices_active_ == 0) {
     delegate_->PrivetRemoveNotification();
   } else {
     delegate_->PrivetNotify(devices_active_, false);
   }
 }
 
 PrivetNotificationsListener::DeviceContext::DeviceContext() {
 }
 
@@ skipping 34 matching lines @@
 }
 
 // static
 bool PrivetNotificationService::IsForced() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kEnableDeviceDiscoveryNotifications);
 }
 
 void PrivetNotificationService::PrivetNotify(int devices_active,
                                              bool added) {
-  base::string16 product_name = l10n_util::GetStringUTF16(
-      IDS_LOCAL_DISCOVERY_SERVICE_NAME_PRINTER);
+  DCHECK_GT(devices_active, 0);
+
+  message_center::RichNotificationData rich_notification_data;
+  rich_notification_data.buttons.push_back(
+      message_center::ButtonInfo(l10n_util::GetStringUTF16(
+          IDS_LOCAL_DISCOVERY_NOTIFICATION_BUTTON_PRINTER)));
+  rich_notification_data.buttons.push_back(
+      message_center::ButtonInfo(l10n_util::GetStringUTF16(
+          IDS_LOCAL_DISCOVERY_NOTIFICATIONS_DISABLE_BUTTON_LABEL)));
 
   base::string16 title = l10n_util::GetPluralStringFUTF16(
       IDS_LOCAL_DISCOVERY_NOTIFICATION_TITLE_PRINTER, devices_active);
   base::string16 body = l10n_util::GetPluralStringFUTF16(
       IDS_LOCAL_DISCOVERY_NOTIFICATION_CONTENTS_PRINTER, devices_active);
-
-  Profile* profile_object = Profile::FromBrowserContext(profile_);
-  message_center::RichNotificationData rich_notification_data;
-
-  rich_notification_data.buttons.push_back(
-      message_center::ButtonInfo(l10n_util::GetStringUTF16(
-          IDS_LOCAL_DISCOVERY_NOTIFICATION_BUTTON_PRINTER)));
-
-  rich_notification_data.buttons.push_back(
-      message_center::ButtonInfo(l10n_util::GetStringUTF16(
-          IDS_LOCAL_DISCOVERY_NOTIFICATIONS_DISABLE_BUTTON_LABEL)));
+  base::string16 product_name =
+      l10n_util::GetStringUTF16(IDS_LOCAL_DISCOVERY_SERVICE_NAME_PRINTER);
 
   Notification notification(
       message_center::NOTIFICATION_TYPE_SIMPLE, title, body,
       ui::ResourceBundle::GetSharedInstance().GetImageNamed(
           IDR_LOCAL_DISCOVERY_CLOUDPRINT_ICON),
       message_center::NotifierId(message_center::NotifierId::SYSTEM_COMPONENT,
                                  kPrivetNotificationID),
       product_name, GURL(kPrivetNotificationOriginUrl), kPrivetNotificationID,
       rich_notification_data, new PrivetNotificationDelegate(profile_));
 
-  bool updated = g_browser_process->notification_ui_manager()->Update(
-      notification, profile_object);
+  auto* notification_ui_manager = g_browser_process->notification_ui_manager();
+  Profile* profile = Profile::FromBrowserContext(profile_);
+  bool updated = notification_ui_manager->Update(notification, profile);
   if (!updated && added &&
       !local_discovery::LocalDiscoveryUIHandler::GetHasVisible()) {
     ReportPrivetUmaEvent(PRIVET_NOTIFICATION_SHOWN);
-    g_browser_process->notification_ui_manager()->Add(notification,
-                                                      profile_object);
+    notification_ui_manager->Add(notification, profile);
   }
 }
 
 void PrivetNotificationService::PrivetRemoveNotification() {
   ReportPrivetUmaEvent(PRIVET_NOTIFICATION_CANCELED);
   Profile* profile_object = Profile::FromBrowserContext(profile_);
   g_browser_process->notification_ui_manager()->CancelById(
       kPrivetNotificationID,
       NotificationUIManager::GetProfileID(profile_object));
 }
@@ skipping 21 matching lines @@
   if (IsForced()) {
     StartLister();
   } else if (*enable_privet_notification_member_) {
     ReportPrivetUmaEvent(PRIVET_SERVICE_STARTED);
     traffic_detector_ =
         new PrivetTrafficDetector(
             net::ADDRESS_FAMILY_IPV4,
             base::Bind(&PrivetNotificationService::StartLister, AsWeakPtr()));
     traffic_detector_->Start();
   } else {
-    traffic_detector_ = NULL;
+    traffic_detector_ = nullptr;
     device_lister_.reset();
-    service_discovery_client_ = NULL;
+    service_discovery_client_ = nullptr;
     privet_notifications_listener_.reset();
   }
 #else
   if (IsForced() || *enable_privet_notification_member_) {
     StartLister();
   } else {
     device_lister_.reset();
-    service_discovery_client_ = NULL;
+    service_discovery_client_ = nullptr;
     privet_notifications_listener_.reset();
   }
 #endif
 }
 
 void PrivetNotificationService::StartLister() {
   ReportPrivetUmaEvent(PRIVET_LISTER_STARTED);
 #if defined(ENABLE_MDNS)
-  traffic_detector_ = NULL;
+  traffic_detector_ = nullptr;
 #endif  // ENABLE_MDNS
   service_discovery_client_ =
       local_discovery::ServiceDiscoverySharedClient::GetInstance();
   device_lister_.reset(
       new PrivetDeviceListerImpl(service_discovery_client_.get(), this));
   device_lister_->Start();
   device_lister_->DiscoverNewDevices(false);
 
   std::unique_ptr<PrivetHTTPAsynchronousFactory> http_factory(
       PrivetHTTPAsynchronousFactory::CreateInstance(
@@ skipping 13 matching lines @@
 }
 
 std::string PrivetNotificationDelegate::id() const {
   return kPrivetNotificationID;
 }
 
 void PrivetNotificationDelegate::ButtonClick(int button_index) {
   if (button_index == 0) {
     ReportPrivetUmaEvent(PRIVET_NOTIFICATION_CLICKED);
     OpenTab(GURL(kPrivetNotificationOriginUrl));
-  } else if (button_index == 1) {
-    ReportPrivetUmaEvent(PRIVET_DISABLE_NOTIFICATIONS_CLICKED);
-    DisableNotifications();
+    return;
   }
+
+  DCHECK_EQ(1, button_index);
+  ReportPrivetUmaEvent(PRIVET_DISABLE_NOTIFICATIONS_CLICKED);
+  DisableNotifications();
 }
 
 void PrivetNotificationDelegate::OpenTab(const GURL& url) {
-  Profile* profile_obj = Profile::FromBrowserContext(profile_);
-
-  chrome::NavigateParams params(profile_obj,
-                              url,
-                              ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
+  Profile* profile = Profile::FromBrowserContext(profile_);
+  chrome::NavigateParams params(profile, url,
+                                ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 }
 
 void PrivetNotificationDelegate::DisableNotifications() {
-  Profile* profile_obj = Profile::FromBrowserContext(profile_);
-
-  profile_obj->GetPrefs()->SetBoolean(
-      prefs::kLocalDiscoveryNotificationsEnabled,
-      false);
+  Profile* profile = Profile::FromBrowserContext(profile_);
+  profile->GetPrefs()->SetBoolean(prefs::kLocalDiscoveryNotificationsEnabled,
+                                  false);
 }
 
 }  // namespace cloud_print