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

ash/system/network/tray_network.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 "ash/system/network/tray_network.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
@@ skipping 72 matching lines @@
   virtual bool CanActivate() const OVERRIDE {
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NonActivatableSettingsBubble);
 };
 
 using ash::internal::TrayNetwork;
 
-int GetErrorIcon(TrayNetwork::ErrorType error_type) {
-  switch(error_type) {
+int GetMessageIcon(TrayNetwork::MessageType message_type) {
+  switch(message_type) {
     case TrayNetwork::ERROR_CONNECT_FAILED:
       return IDR_AURA_UBER_TRAY_NETWORK_FAILED;
     case TrayNetwork::ERROR_DATA_LOW:
       return IDR_AURA_UBER_TRAY_NETWORK_DATA_LOW;
     case TrayNetwork::ERROR_DATA_NONE:
       return IDR_AURA_UBER_TRAY_NETWORK_DATA_NONE;
+    case TrayNetwork::MESSAGE_DATA_PROMO:
+      return IDR_AURA_UBER_TRAY_NOTIFICATION_3G;
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace
 
 namespace ash {
 namespace internal {
 
 namespace tray {
 
 enum ColorTheme {
   LIGHT,
   DARK,
 };
 
-class NetworkErrors {
+class NetworkMessages {
  public:
   struct Message {
     Message() : delegate(NULL) {}
     Message(NetworkTrayDelegate* in_delegate,
             const string16& in_title,
             const string16& in_message,
-            const string16& in_link_text) :
+            const std::vector<string16>& in_links) :
         delegate(in_delegate),
         title(in_title),
         message(in_message),
-        link_text(in_link_text) {}
+        links(in_links) {}
     NetworkTrayDelegate* delegate;
     string16 title;
     string16 message;
-    string16 link_text;
+    std::vector<string16> links;
   };
-  typedef std::map<TrayNetwork::ErrorType, Message> ErrorMap;
+  typedef std::map<TrayNetwork::MessageType, Message> MessageMap;
 
-  ErrorMap& messages() { return messages_; }
-  const ErrorMap& messages() const { return messages_; }
+  MessageMap& messages() { return messages_; }
+  const MessageMap& messages() const { return messages_; }
 
  private:
-  ErrorMap messages_;
+  MessageMap messages_;
 };
 
 class NetworkTrayView : public TrayItemView {
  public:
   NetworkTrayView(ColorTheme size, bool tray_icon)
       : color_theme_(size), tray_icon_(tray_icon) {
     SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0));
 
     image_view_ = color_theme_ == DARK ?
@@ skipping 577 matching lines @@
   virtual TrayNetwork::DetailedViewType GetViewType() const OVERRIDE {
     return TrayNetwork::WIFI_VIEW;
   }
 
   virtual void Update() OVERRIDE {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkWifiDetailedView);
 };
 
-class NetworkErrorView : public views::View,
-                         public views::LinkListener {
+class NetworkMessageView : public views::View,
+                           public views::LinkListener {
  public:
-  NetworkErrorView(TrayNetwork* tray,
-                   TrayNetwork::ErrorType error_type,
-                   const NetworkErrors::Message& error)
+  NetworkMessageView(TrayNetwork* tray,
+                     TrayNetwork::MessageType message_type,
+                     const NetworkMessages::Message& network_msg)
       : tray_(tray),
-        error_type_(error_type) {
+        message_type_(message_type) {
     SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1));
 
-    views::Label* title = new views::Label(error.title);
-    title->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
-    title->SetFont(title->font().DeriveFont(0, gfx::Font::BOLD));
-    AddChildView(title);
+    if (!network_msg.title.empty()) {
+      views::Label* title = new views::Label(network_msg.title);
+      title->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+      title->SetFont(title->font().DeriveFont(0, gfx::Font::BOLD));
+      AddChildView(title);
+    }
 
-    views::Label* message = new views::Label(error.message);
-    message->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
-    message->SetMultiLine(true);
-    message->SizeToFit(kTrayNotificationContentsWidth);
-    AddChildView(message);
+    if (!network_msg.message.empty()) {
+      views::Label* message = new views::Label(network_msg.message);
+      message->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+      message->SetMultiLine(true);
+      message->SizeToFit(kTrayNotificationContentsWidth);
+      AddChildView(message);
+    }
 
-    if (!error.link_text.empty()) {
-      views::Link* link = new views::Link(error.link_text);
-      link->set_listener(this);
-      link->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
-      link->SetMultiLine(true);
-      link->SizeToFit(kTrayNotificationContentsWidth);
-      AddChildView(link);
+    if (!network_msg.links.empty()) {
+      for (size_t i = 0; i < network_msg.links.size(); ++i) {
+        views::Link* link = new views::Link(network_msg.links[i]);
+        link->set_id(i);
+        link->set_listener(this);
+        link->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+        link->SetMultiLine(true);
+        link->SizeToFit(kTrayNotificationContentsWidth);
+        AddChildView(link);
+      }
     }
   }
 
-  virtual ~NetworkErrorView() {
+  virtual ~NetworkMessageView() {
   }
 
   // Overridden from views::LinkListener.
   virtual void LinkClicked(views::Link* source, int event_flags) OVERRIDE {
-    tray_->LinkClicked(error_type_);
+    tray_->LinkClicked(message_type_, source->id());
   }
 
-  TrayNetwork::ErrorType error_type() const { return error_type_; }
+  TrayNetwork::MessageType message_type() const { return message_type_; }
 
  private:
   TrayNetwork* tray_;
-  TrayNetwork::ErrorType error_type_;
+  TrayNetwork::MessageType message_type_;
 
-  DISALLOW_COPY_AND_ASSIGN(NetworkErrorView);
+  DISALLOW_COPY_AND_ASSIGN(NetworkMessageView);
 };
 
 class NetworkNotificationView : public TrayNotificationView {
  public:
   explicit NetworkNotificationView(TrayNetwork* tray)
       : TrayNotificationView(tray, 0) {
-    CreateErrorView();
-    InitView(network_error_view_);
+    CreateMessageView();
+    InitView(network_message_view_);
     SetIconImage(*ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        GetErrorIcon(network_error_view_->error_type())));
+        GetMessageIcon(network_message_view_->message_type())));
   }
 
   // Overridden from TrayNotificationView.
   virtual void OnClose() OVERRIDE {
-    tray_network()->ClearNetworkError(network_error_view_->error_type());
+    tray_network()->ClearNetworkMessage(network_message_view_->message_type());
   }
 
   virtual void OnClickAction() OVERRIDE {
-    tray()->PopupDetailedView(0, true);
+    if (network_message_view_->message_type() !=
+        TrayNetwork::MESSAGE_DATA_PROMO)
+      tray()->PopupDetailedView(0, true);
   }
 
   void Update() {
-    CreateErrorView();
-    UpdateViewAndImage(network_error_view_,
-                       *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-                           GetErrorIcon(network_error_view_->error_type())));
+    CreateMessageView();
+    UpdateViewAndImage(network_message_view_,
+        *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+            GetMessageIcon(network_message_view_->message_type())));
   }
 
  private:
   TrayNetwork* tray_network() {
     return static_cast<TrayNetwork*>(tray());
   }
 
-  void CreateErrorView() {
-    // Display the first (highest priority) error.
-    CHECK(!tray_network()->errors()->messages().empty());
-    NetworkErrors::ErrorMap::const_iterator iter =
-        tray_network()->errors()->messages().begin();
-    network_error_view_ =
-        new NetworkErrorView(tray_network(), iter->first, iter->second);
+  void CreateMessageView() {
+    // Display the first (highest priority) message.
+    CHECK(!tray_network()->messages()->messages().empty());
+    NetworkMessages::MessageMap::const_iterator iter =
+        tray_network()->messages()->messages().begin();
+    network_message_view_ =
+        new NetworkMessageView(tray_network(), iter->first, iter->second);
   }
 
-  tray::NetworkErrorView* network_error_view_;
+  tray::NetworkMessageView* network_message_view_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkNotificationView);
 };
 
 }  // namespace tray
 
 TrayNetwork::TrayNetwork()
     : tray_(NULL),
       default_(NULL),
       detailed_(NULL),
       notification_(NULL),
-      errors_(new tray::NetworkErrors()),
+      messages_(new tray::NetworkMessages()),
       request_wifi_view_(false) {
 }
 
 TrayNetwork::~TrayNetwork() {
 }
 
 views::View* TrayNetwork::CreateTrayView(user::LoginStatus status) {
   CHECK(tray_ == NULL);
   tray_ = new tray::NetworkTrayView(tray::LIGHT, true /*tray_icon*/);
   return tray_;
@@ skipping 13 matching lines @@
     detailed_ = new tray::NetworkWifiDetailedView(!delegate->GetWifiEnabled());
     request_wifi_view_ = false;
   } else {
     detailed_ = new tray::NetworkListDetailedView(status);
   }
   return detailed_;
 }
 
 views::View* TrayNetwork::CreateNotificationView(user::LoginStatus status) {
   CHECK(notification_ == NULL);
-  if (errors_->messages().empty())
-    return NULL;  // Error has already been cleared.
+  if (messages_->messages().empty())
+    return NULL;  // Message has already been cleared.
   notification_ = new tray::NetworkNotificationView(this);
   return notification_;
 }
 
 void TrayNetwork::DestroyTrayView() {
   tray_ = NULL;
 }
 
 void TrayNetwork::DestroyDefaultView() {
   default_ = NULL;
@@ skipping 16 matching lines @@
 
 void TrayNetwork::OnNetworkRefresh(const NetworkIconInfo& info) {
   if (tray_)
     tray_->Update(info);
   if (default_)
     default_->Update();
   if (detailed_)
     detailed_->Update();
 }
 
-void TrayNetwork::SetNetworkError(NetworkTrayDelegate* delegate,
-                                  ErrorType error_type,
-                                  const string16& title,
-                                  const string16& message,
-                                  const string16& link_text) {
-  errors_->messages()[error_type] =
-      tray::NetworkErrors::Message(delegate, title, message, link_text);
+void TrayNetwork::SetNetworkMessage(NetworkTrayDelegate* delegate,
+                                   MessageType message_type,
+                                   const string16& title,
+                                   const string16& message,
+                                   const std::vector<string16>& links) {
+  messages_->messages()[message_type] =
+      tray::NetworkMessages::Message(delegate, title, message, links);
   if (notification_)
     notification_->Update();
   else
     ShowNotificationView();
 }
 
-void TrayNetwork::ClearNetworkError(ErrorType error_type) {
-  errors_->messages().erase(error_type);
-  if (errors_->messages().empty()) {
+void TrayNetwork::ClearNetworkMessage(MessageType message_type) {
+  messages_->messages().erase(message_type);
+  if (messages_->messages().empty()) {
     if (notification_)
       HideNotificationView();
     return;
   }
   if (notification_)
     notification_->Update();
   else
     ShowNotificationView();
 }
 
 void TrayNetwork::OnWillToggleWifi() {
   if (!detailed_ || detailed_->GetViewType() == WIFI_VIEW) {
     request_wifi_view_ = true;
     PopupDetailedView(kTrayPopupAutoCloseDelayForTextInSeconds, false);
   }
 }
 
-void TrayNetwork::LinkClicked(ErrorType error_type) {
-  tray::NetworkErrors::ErrorMap::const_iterator iter =
-      errors()->messages().find(error_type);
-  if (iter != errors()->messages().end() && iter->second.delegate)
-    iter->second.delegate->NotificationLinkClicked();
+void TrayNetwork::LinkClicked(MessageType message_type, int link_id) {
+  tray::NetworkMessages::MessageMap::const_iterator iter =
+      messages()->messages().find(message_type);
+  if (iter != messages()->messages().end() && iter->second.delegate)
+    iter->second.delegate->NotificationLinkClicked(link_id);
 }
 
 }  // namespace internal
 }  // namespace ash