Update NetworkStateNotifier to use message_center.

ash/system/chromeos/network/network_connect.cc

 // Copyright (c) 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 "ash/system/chromeos/network/network_connect.h"
 
 #include "ash/shell.h"
-#include "ash/system/chromeos/network/network_observer.h"
 #include "ash/system/chromeos/network/network_state_notifier.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/message_center/message_center.h"
+#include "ui/message_center/notification.h"
 
 using chromeos::DeviceState;
 using chromeos::NetworkConfigurationHandler;
 using chromeos::NetworkConnectionHandler;
 using chromeos::NetworkHandler;
 using chromeos::NetworkProfile;
 using chromeos::NetworkProfileHandler;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
@@ skipping 71 matching lines @@
     return;
 
   ash::Shell::GetInstance()->system_tray_delegate()->ConfigureNetwork(
       service_path);
 }
 
 void OnConnectSucceeded(const std::string& service_path) {
   NET_LOG_USER("Connect Succeeded", service_path);
   if (!ash::Shell::HasInstance())
     return;
-  ash::Shell::GetInstance()->system_tray_notifier()->NotifyClearNetworkMessage(
-      NetworkObserver::ERROR_CONNECT_FAILED);
+  message_center::MessageCenter::Get()->RemoveNotification(
+      network_connect::kNetworkConnectNotificationId, false /* by_user */);
 }
 
 // If |check_error_state| is true, error state for the network is checked,
 // otherwise any current error state is ignored (e.g. for recently configured
 // networks or repeat connect attempts). |owning_window| will be used to parent
 // any configuration UI on failure and may be NULL (in which case the default
 // window will be used).
 void CallConnectToNetwork(const std::string& service_path,
                           bool check_error_state,
                           gfx::NativeWindow owning_window) {
   if (!ash::Shell::HasInstance())
     return;
-  ash::Shell::GetInstance()->system_tray_notifier()->NotifyClearNetworkMessage(
-      NetworkObserver::ERROR_CONNECT_FAILED);
+  message_center::MessageCenter::Get()->RemoveNotification(
+      network_connect::kNetworkConnectNotificationId, false /* by_user */);
 
   NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
       service_path,
       base::Bind(&OnConnectSucceeded, service_path),
       base::Bind(&OnConnectFailed, service_path, owning_window),
       check_error_state);
 }
 
 void OnActivateFailed(const std::string& service_path,
                      const std::string& error_name,
@@ skipping 98 matching lines @@
       base::Bind(&ClearPropertiesAndConnect,
                  service_path,
                  properties_to_clear),
       base::Bind(&SetPropertiesFailed, "SetProperties", service_path));
 }
 
 }  // namespace
 
 namespace network_connect {
 
+const char kNetworkConnectNotificationId[] =
+    "chrome://settings/internet/connect";
+const char kNetworkActivateNotificationId[] =
+    "chrome://settings/internet/activate";
+
 void ConnectToNetwork(const std::string& service_path,
                       gfx::NativeWindow owning_window) {
   NET_LOG_USER("ConnectToNetwork", service_path);
+  const NetworkState* network =
+      NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(service_path);
+  if (network && !network->error().empty()) {
+    NET_LOG_USER("Configure: " + network->error(), service_path);
+    // If the network is in an error state, show the configuration UI
+    // directly to avoid a spurrious notification.
+    ash::Shell::GetInstance()->system_tray_delegate()->ConfigureNetwork(
+        service_path);
+    return;
+  }
   const bool check_error_state = true;
   CallConnectToNetwork(service_path, check_error_state, owning_window);
 }
 
 void ActivateCellular(const std::string& service_path) {
   NET_LOG_USER("ActivateCellular", service_path);
   const NetworkState* cellular =
       NetworkHandler::Get()->network_state_handler()->
       GetNetworkState(service_path);
   if (!cellular || cellular->type() != flimflam::kTypeCellular) {
@@ skipping 30 matching lines @@
 void ShowMobileSetup(const std::string& service_path) {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   const NetworkState* cellular = handler->GetNetworkState(service_path);
   if (!cellular || cellular->type() != flimflam::kTypeCellular) {
     NET_LOG_ERROR("ShowMobileSetup without Cellular network", service_path);
     return;
   }
   if (cellular->activation_state() != flimflam::kActivationStateActivated &&
       cellular->activate_over_non_cellular_networks() &&
       !handler->DefaultNetwork()) {
-    std::string technology = cellular->network_technology();
-    ash::NetworkObserver::NetworkType network_type =
-        (technology == flimflam::kNetworkTechnologyLte ||
-         technology == flimflam::kNetworkTechnologyLteAdvanced)
-        ? ash::NetworkObserver::NETWORK_CELLULAR_LTE
-        : ash::NetworkObserver::NETWORK_CELLULAR;
-    ash::Shell::GetInstance()->system_tray_notifier()->NotifySetNetworkMessage(
-        NULL,
-        ash::NetworkObserver::ERROR_CONNECT_FAILED,
-        network_type,
-        l10n_util::GetStringUTF16(IDS_NETWORK_ACTIVATION_ERROR_TITLE),
-        l10n_util::GetStringFUTF16(IDS_NETWORK_ACTIVATION_NEEDS_CONNECTION,
-                                   UTF8ToUTF16((cellular->name()))),
-        std::vector<string16>());
+    message_center::MessageCenter::Get()->AddNotification(
+        message_center::Notification::CreateSystemNotification(
+            ash::network_connect::kNetworkActivateNotificationId,
+            l10n_util::GetStringUTF16(IDS_NETWORK_ACTIVATION_ERROR_TITLE),
+            l10n_util::GetStringFUTF16(IDS_NETWORK_ACTIVATION_NEEDS_CONNECTION,
+                                       UTF8ToUTF16(cellular->name())),
+            ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+                IDR_AURA_UBER_TRAY_CELLULAR_NETWORK_FAILED),
+            base::Bind(&ash::network_connect::ShowNetworkSettings,
+                       service_path)));

[Jun Mukai, 2013/08/20 22:25:36]

As we discussed on another crbug, the clicked notification doesn't remove the
notification.
The specified callback will be called, but the notification remains in the
message center and visible to the user.  Is it expected?  I think it might be
better to remove the notification at the same time.
Otherwise, the stale notification may remain even after the user takes the
action.

[stevenjb, 2013/08/20 22:33:15]

Yes, it is expected that the notification will be dismissed on click.

Let's continue to discuss this in crbug.com/276633, but I can't think of an
example of a notification where we would -not- want to dismiss it after clicking
on it. If we don't make that the default we will need to provide a parameter to
dismiss on click, otherwise it is going to be tedious to do that for every
notification that wants that behavior.

     return;
   }
   ash::Shell::GetInstance()->system_tray_delegate()->ShowMobileSetupDialog(
       service_path);
 }
 
 void ConfigureNetworkAndConnect(const std::string& service_path,
                                 const base::DictionaryValue& properties,
                                 bool shared) {
   NET_LOG_USER("ConfigureNetworkAndConnect", service_path);
@@ skipping 101 matching lines @@
 
 void ShowNetworkSettings(const std::string& service_path) {
   if (!ash::Shell::HasInstance())
     return;
   ash::Shell::GetInstance()->system_tray_delegate()->ShowNetworkSettings(
       service_path);
 }
 
 }  // network_connect
 }  // ash