Data promo notification should follow the normal ash notifications theme. This

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"
@@ skipping 30 matching lines @@
   return prefs->GetBoolean(prefs::kShowPlanNotifications);
 }
 
 }  // namespace
 
 namespace chromeos {
 
 class NetworkMessageNotification : public ash::NetworkTrayDelegate {
  public:
   NetworkMessageNotification(Profile* profile,
-                             ash::NetworkObserver::ErrorType error_type)
+                             ash::NetworkObserver::MessageType 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:
+      case ash::NetworkObserver::MESSAGE_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:
+      case ash::NetworkObserver::MESSAGE_DATA_NONE:
         id = "network_no_data.chromeos";
         icon_id = IDR_NOTIFICATION_BARS_EMPTY;
         title_ = l10n_util::GetStringUTF16(IDS_NETWORK_OUT_OF_DATA_TITLE);
         break;
+      case ash::NetworkObserver::MESSAGE_DATA_PROMO:
+        NOTREACHED();
+        break;
     }
     DCHECK(!id.empty());
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             ash::switches::kAshNotifyDisabled)) {
       system_notification_.reset(
           new SystemNotification(profile, id, icon_id, title_));
     }
   }
 
   // Overridden from ash::NetworkTrayDelegate:
-  virtual void NotificationLinkClicked() {
+  virtual void NotificationLinkClicked(size_t index) OVERRIDE {
     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()->system_tray()->network_observer()->
-          ClearNetworkError(error_type_);
+          ClearNetworkMessage(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;
+      std::vector<string16> links;
+      links.push_back(link_text);
       ash::Shell::GetInstance()->system_tray()->network_observer()->
-          SetNetworkError(this, error_type_, title_, message, link_text);
+          SetNetworkMessage(this, error_type_, title_, message, links);
     }
   }
 
   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_;
+  ash::NetworkObserver::MessageType 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));
+          ash::NetworkObserver::MESSAGE_DATA_LOW));
   notification_no_data_.reset(
       new NetworkMessageNotification(
           profile,
-          ash::NetworkObserver::ERROR_DATA_NONE));
+          ash::NetworkObserver::MESSAGE_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);
@@ skipping 232 matching lines @@
   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