Add NetworkNotificationView to tray_network.

chrome/browser/chromeos/network_message_observer.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/network_message_observer.h"
 
+#include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
+#include "ash/system/network/network_observer.h"
+#include "ash/system/tray/system_tray.h"
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/notifications/balloon_view_host_chromeos.h"
+#include "chrome/browser/chromeos/notifications/system_notification.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/time_format.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // Returns prefs::kShowPlanNotifications in the profile of the last active
 // browser. If there is no active browser, returns true.
 bool ShouldShowMobilePlanNotifications() {
   Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
   PrefService* prefs = profile->GetPrefs();
   return prefs->GetBoolean(prefs::kShowPlanNotifications);
 }
 
 }  // namespace
 
 namespace chromeos {
 
-NetworkMessageObserver::NetworkMessageObserver(Profile* profile)
-    : notification_connection_error_(profile, "network_connection.chromeos",
-          IDR_NOTIFICATION_NETWORK_FAILED,
-          l10n_util::GetStringUTF16(IDS_NETWORK_CONNECTION_ERROR_TITLE)),
-      notification_low_data_(profile, "network_low_data.chromeos",
-          IDR_NOTIFICATION_BARS_CRITICAL,
-          l10n_util::GetStringUTF16(IDS_NETWORK_LOW_DATA_TITLE)),
-      notification_no_data_(profile, "network_no_data.chromeos",
-          IDR_NOTIFICATION_BARS_EMPTY,
-          l10n_util::GetStringUTF16(IDS_NETWORK_OUT_OF_DATA_TITLE)) {
+class NetworkMessageNotification : public ash::NetworkTrayDelegate {
+ public:
+  NetworkMessageNotification(Profile* profile,
+                             ash::NetworkObserver::ErrorType error_type)
+      : error_type_(error_type) {
+    std::string id;
+    int icon_id = 0;
+    switch (error_type) {
+      case ash::NetworkObserver::ERROR_CONNECT_FAILED:
+        id = "network_connection.chromeos";
+        icon_id = IDR_NOTIFICATION_NETWORK_FAILED;
+        title_ = l10n_util::GetStringUTF16(IDS_NETWORK_CONNECTION_ERROR_TITLE);
+        break;
+      case ash::NetworkObserver::ERROR_DATA_LOW:
+        id = "network_low_data.chromeos";
+        icon_id = IDR_NOTIFICATION_BARS_CRITICAL;
+        title_ = l10n_util::GetStringUTF16(IDS_NETWORK_LOW_DATA_TITLE);
+        break;
+      case ash::NetworkObserver::ERROR_DATA_NONE:
+        id = "network_no_data.chromeos";
+        icon_id = IDR_NOTIFICATION_BARS_EMPTY;
+        title_ = l10n_util::GetStringUTF16(IDS_NETWORK_OUT_OF_DATA_TITLE);
+        break;
+      default:
+        NOTREACHED();

[Greg Spencer (Chromium), 2012/05/23 19:00:28]

Wouldn't you want to move this NOTREACHED() outside the switch so that Clang
will tell us if not all values are handled?

You could say:
if (id.empty())
  NOTREACHED() << "Invalid error type received";

[stevenjb, 2012/05/23 19:21:52]

Yes, good point. Fixed.

+    }
+    if (!CommandLine::ForCurrentProcess()->HasSwitch(
+            ash::switches::kAshNotify) && !id.empty()) {
+      system_notification_.reset(
+          new SystemNotification(profile, id, icon_id, title_));
+    }
+  }
+
+  // Overridden from ash::NetworkTrayDelegate:
+  virtual void NotificationLinkClicked() {
+    base::ListValue empty_value;
+    if (!callback_.is_null())
+      callback_.Run(&empty_value);
+  }
+
+  void Hide() {
+    if (system_notification_.get()) {
+      system_notification_->Hide();
+    } else {
+      ash::Shell::GetInstance()->tray()->network_observer()->
+          ClearNetworkError(error_type_);
+    }
+  }
+
+  void SetTitle(const string16& title) {
+    title_ = title;
+    if (system_notification_.get()) {
+      system_notification_->set_title(title);
+    }
+  }
+
+  void Show(const string16& message,
+            const string16& link_text,
+            const BalloonViewHost::MessageCallback& callback,
+            bool urgent, bool sticky) {
+    if (system_notification_.get()) {
+      system_notification_->Show(message, link_text, callback, urgent, sticky);
+    } else {
+      callback_ = callback;
+      ash::Shell::GetInstance()->tray()->network_observer()->
+          SetNetworkError(this, error_type_, title_, message, link_text);
+    }
+  }
+
+  void ShowAlways(const string16& message,
+                  const string16& link_text,
+                  const BalloonViewHost::MessageCallback& callback,
+                  bool urgent, bool sticky) {
+    if (system_notification_.get()) {
+      // Hide if already shown to force show it in case user has closed it.
+      if (system_notification_->visible())
+        system_notification_->Hide();
+    }
+    Show(message, link_text, callback, urgent, sticky);
+  }
+
+ private:
+  string16 title_;
+  scoped_ptr<SystemNotification> system_notification_;
+  ash::NetworkObserver::ErrorType error_type_;
+  BalloonViewHost::MessageCallback callback_;
+};
+
+NetworkMessageObserver::NetworkMessageObserver(Profile* profile) {
+  notification_connection_error_.reset(
+      new NetworkMessageNotification(
+          profile, ash::NetworkObserver::ERROR_CONNECT_FAILED));
+  notification_low_data_.reset(
+      new NetworkMessageNotification(
+          profile,
+          ash::NetworkObserver::ERROR_DATA_LOW));
+  notification_no_data_.reset(
+      new NetworkMessageNotification(
+          profile,
+          ash::NetworkObserver::ERROR_DATA_NONE));
   NetworkLibrary* netlib = CrosLibrary::Get()->GetNetworkLibrary();
   OnNetworkManagerChanged(netlib);
   // Note that this gets added as a NetworkManagerObserver,
   // CellularDataPlanObserver, and UserActionObserver in
   // startup_browser_creator.cc
 }
 
 NetworkMessageObserver::~NetworkMessageObserver() {
   NetworkLibrary* netlib = CrosLibrary::Get()->GetNetworkLibrary();
   netlib->RemoveNetworkManagerObserver(this);
   netlib->RemoveCellularDataPlanObserver(this);
   netlib->RemoveUserActionObserver(this);
-  notification_connection_error_.Hide();
-  notification_low_data_.Hide();
-  notification_no_data_.Hide();
+  notification_connection_error_->Hide();
+  notification_low_data_->Hide();
+  notification_no_data_->Hide();
 }
 
 // static
 bool NetworkMessageObserver::IsApplicableBackupPlan(
     const CellularDataPlan* plan, const CellularDataPlan* other_plan) {
   // By applicable plan, we mean that the other plan has data AND the timeframe
   // will apply: (unlimited OR used bytes < max bytes) AND
   //   ((start time - 1 sec) <= end time of currently active plan).
   // In other words, there is data available and there is no gap of more than a
   // second in time between the old plan and the new plan.
@@ skipping 13 matching lines @@
       ProfileManager::GetDefaultProfileOrOffTheRecord());
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   const chromeos::CellularNetwork* cellular = lib->cellular_network();
   if (!cellular)
     return;
   browser->ShowSingletonTab(GURL(cellular->payment_url()));
 }
 
 void NetworkMessageObserver::InitNewPlan(const CellularDataPlan* plan) {
-  notification_low_data_.Hide();
-  notification_no_data_.Hide();
+  notification_low_data_->Hide();
+  notification_no_data_->Hide();
   if (plan->plan_type == CELLULAR_DATA_PLAN_UNLIMITED) {
-    notification_no_data_.set_title(
+    notification_no_data_->SetTitle(
         l10n_util::GetStringFUTF16(IDS_NETWORK_DATA_EXPIRED_TITLE,
                                    ASCIIToUTF16(plan->plan_name)));
-    notification_low_data_.set_title(
+    notification_low_data_->SetTitle(
         l10n_util::GetStringFUTF16(IDS_NETWORK_NEARING_EXPIRATION_TITLE,
                                    ASCIIToUTF16(plan->plan_name)));
   } else {
-    notification_no_data_.set_title(
+    notification_no_data_->SetTitle(
         l10n_util::GetStringFUTF16(IDS_NETWORK_OUT_OF_DATA_TITLE,
                                    ASCIIToUTF16(plan->plan_name)));
-    notification_low_data_.set_title(
+    notification_low_data_->SetTitle(
         l10n_util::GetStringFUTF16(IDS_NETWORK_LOW_DATA_TITLE,
                                    ASCIIToUTF16(plan->plan_name)));
   }
 }
 
 void NetworkMessageObserver::ShowNeedsPlanNotification(
     const CellularNetwork* cellular) {
-  notification_no_data_.set_title(
+  notification_no_data_->SetTitle(
       l10n_util::GetStringFUTF16(IDS_NETWORK_NO_DATA_PLAN_TITLE,
                                  UTF8ToUTF16(cellular->name())));
-  notification_no_data_.Show(
+  notification_no_data_->Show(
       l10n_util::GetStringFUTF16(
           IDS_NETWORK_NO_DATA_PLAN_MESSAGE,
           UTF8ToUTF16(cellular->name())),
       l10n_util::GetStringUTF16(IDS_NETWORK_PURCHASE_MORE_MESSAGE),
       base::Bind(&NetworkMessageObserver::OpenMobileSetupPage, AsWeakPtr()),
       false, false);
 }
 
 void NetworkMessageObserver::ShowNoDataNotification(
     CellularDataPlanType plan_type) {
-  notification_low_data_.Hide();  // Hide previous low data notification.
+  notification_low_data_->Hide();  // Hide previous low data notification.
   string16 message = plan_type == CELLULAR_DATA_PLAN_UNLIMITED ?
       TimeFormat::TimeRemaining(base::TimeDelta()) :
       l10n_util::GetStringFUTF16(IDS_NETWORK_DATA_REMAINING_MESSAGE,
                                  ASCIIToUTF16("0"));
-  notification_no_data_.Show(message,
+  notification_no_data_->Show(message,
       l10n_util::GetStringUTF16(IDS_NETWORK_PURCHASE_MORE_MESSAGE),
       base::Bind(&NetworkMessageObserver::OpenMobileSetupPage, AsWeakPtr()),
       false, false);
 }
 
 void NetworkMessageObserver::ShowLowDataNotification(
     const CellularDataPlan* plan) {
   string16 message;
   if (plan->plan_type == CELLULAR_DATA_PLAN_UNLIMITED) {
     message = plan->GetPlanExpiration();
   } else {
     int64 remaining_mbytes = plan->remaining_data() / (1024 * 1024);
     message = l10n_util::GetStringFUTF16(IDS_NETWORK_DATA_REMAINING_MESSAGE,
         UTF8ToUTF16(base::Int64ToString(remaining_mbytes)));
   }
-  notification_low_data_.Show(message,
+  notification_low_data_->Show(message,
       l10n_util::GetStringUTF16(IDS_NETWORK_MORE_INFO_MESSAGE),
       base::Bind(&NetworkMessageObserver::OpenMoreInfoPage, AsWeakPtr()),
       false, false);
 }
 
 void NetworkMessageObserver::OnNetworkManagerChanged(NetworkLibrary* cros) {
   const Network* new_failed_network = NULL;
   // Check to see if we have any newly failed networks.
   for (WifiNetworkVector::const_iterator it = cros->wifi_networks().begin();
        it != cros->wifi_networks().end(); it++) {
@@ skipping 34 matching lines @@
       const VirtualNetwork* net = *it;
       if (net->notify_failure()) {
         new_failed_network = net;
         break;  // There should only be one failed network.
       }
     }
   }
 
   // Show connection error notification if necessary.
   if (new_failed_network) {
-    // Hide if already shown to force show it in case user has closed it.
-    if (notification_connection_error_.visible())
-      notification_connection_error_.Hide();
-    notification_connection_error_.Show(l10n_util::GetStringFUTF16(
-        IDS_NETWORK_CONNECTION_ERROR_MESSAGE_WITH_DETAILS,
-        UTF8ToUTF16(new_failed_network->name()),
-        UTF8ToUTF16(new_failed_network->GetErrorString())), false, false);
+    notification_connection_error_->ShowAlways(
+        l10n_util::GetStringFUTF16(
+            IDS_NETWORK_CONNECTION_ERROR_MESSAGE_WITH_DETAILS,
+            UTF8ToUTF16(new_failed_network->name()),
+            UTF8ToUTF16(new_failed_network->GetErrorString())),
+        string16(), BalloonViewHost::MessageCallback(), false, false);
   }
 }
 
 void NetworkMessageObserver::OnCellularDataPlanChanged(NetworkLibrary* cros) {
   if (!ShouldShowMobilePlanNotifications())
     return;
   const CellularNetwork* cellular = cros->cellular_network();
   if (!cellular || !cellular->SupportsDataPlan())
     return;
 
@@ skipping 43 matching lines @@
     if (!new_plan && (cellular_data_left_ != CellularNetwork::DATA_VERY_LOW))
       ShowLowDataNotification(current_plan);
   }
 
   SaveLastCellularInfo(cellular, current_plan);
 }
 
 void NetworkMessageObserver::OnConnectionInitiated(NetworkLibrary* cros,
                                                    const Network* network) {
   // If user initiated any network connection, we hide the error notification.
-  notification_connection_error_.Hide();
+  notification_connection_error_->Hide();
 }
 
 void NetworkMessageObserver::SaveLastCellularInfo(
     const CellularNetwork* cellular, const CellularDataPlan* plan) {
   DCHECK(cellular);
   cellular_service_path_ = cellular->service_path();
   cellular_data_left_ = cellular->data_left();
   if (plan) {
     cellular_data_plan_unique_id_ = plan->GetUniqueIdentifier();
     cellular_data_plan_type_ = plan->plan_type;
   } else {
     cellular_data_plan_unique_id_ = std::string();
     cellular_data_plan_type_ = CELLULAR_DATA_PLAN_UNKNOWN;
   }
 }
 
 }  // namespace chromeos