Add Ash notification UI for OutOfCredits network property

ash/system/chromeos/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/chromeos/network/tray_network.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/system/chromeos/network/network_icon_animation.h"
 #include "ash/system/chromeos/network/network_list_detailed_view.h"
 #include "ash/system/chromeos/network/network_list_detailed_view_base.h"
 #include "ash/system/chromeos/network/network_state_list_detailed_view.h"
 #include "ash/system/chromeos/network/network_state_notifier.h"
+#include "ash/system/chromeos/network/network_tray_delegate.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray/tray_item_more.h"
 #include "ash/system/tray/tray_item_view.h"
 #include "ash/system/tray/tray_notification_view.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.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/accessibility/accessible_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/link_listener.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/widget/widget.h"
 
+using ash::internal::TrayNetwork;
+using ash::NetworkObserver;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
 namespace {
 
-using ash::internal::TrayNetwork;
-
-int GetMessageIcon(
-    TrayNetwork::MessageType message_type,
-    TrayNetwork::NetworkType network_type) {
+int GetMessageIcon(NetworkObserver::MessageType message_type,
+                   NetworkObserver::NetworkType network_type) {
   switch(message_type) {
-    case TrayNetwork::ERROR_CONNECT_FAILED:
-      if (TrayNetwork::NETWORK_CELLULAR == network_type)
+    case NetworkObserver::ERROR_CONNECT_FAILED:
+      if (NetworkObserver::NETWORK_CELLULAR == network_type)
         return IDR_AURA_UBER_TRAY_CELLULAR_NETWORK_FAILED;
       else
         return IDR_AURA_UBER_TRAY_NETWORK_FAILED;
-    case TrayNetwork::MESSAGE_DATA_PROMO:
+    case NetworkObserver::ERROR_OUT_OF_CREDITS:
+    case NetworkObserver::MESSAGE_DATA_PROMO:
       if (network_type == TrayNetwork::NETWORK_CELLULAR_LTE)
         return IDR_AURA_UBER_TRAY_NOTIFICATION_LTE;
       else
         return IDR_AURA_UBER_TRAY_NOTIFICATION_3G;
   }
   NOTREACHED();
   return 0;
 }
 
 bool UseNewNetworkHandlers() {
   return !CommandLine::ForCurrentProcess()->HasSwitch(
       ash::switches::kAshDisableNewNetworkStatusArea) &&
       NetworkStateHandler::IsInitialized();
 }
 
 }  // namespace
 
 namespace ash {
 namespace internal {
 
 namespace tray {
 
 class NetworkMessages {
  public:
   struct Message {
     Message() : delegate(NULL) {}
     Message(NetworkTrayDelegate* in_delegate,
-            TrayNetwork::NetworkType network_type,
+            NetworkObserver::NetworkType network_type,
             const string16& in_title,
             const string16& in_message,
             const std::vector<string16>& in_links) :
         delegate(in_delegate),
         network_type_(network_type),
         title(in_title),
         message(in_message),
         links(in_links) {}
     NetworkTrayDelegate* delegate;
-    TrayNetwork::NetworkType network_type_;
+    NetworkObserver::NetworkType network_type_;
     string16 title;
     string16 message;
     std::vector<string16> links;
   };
-  typedef std::map<TrayNetwork::MessageType, Message> MessageMap;
+  typedef std::map<NetworkObserver::MessageType, Message> MessageMap;
 
   MessageMap& messages() { return messages_; }
   const MessageMap& messages() const { return messages_; }
 
  private:
   MessageMap messages_;
 };
 
 class NetworkTrayView : public TrayItemView,
                         public network_icon::AnimationObserver {
@@ skipping 182 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkWifiDetailedView);
 };
 
 class NetworkMessageView : public views::View,
                            public views::LinkListener {
  public:
   NetworkMessageView(TrayNetwork* tray_network,
-                     TrayNetwork::MessageType message_type,
+                     NetworkObserver::MessageType message_type,
                      const NetworkMessages::Message& network_msg)
       : tray_network_(tray_network),
         message_type_(message_type),
         network_type_(network_msg.network_type_) {
     SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1));
 
     if (!network_msg.title.empty()) {
       views::Label* title = new views::Label(network_msg.title);
       title->SetHorizontalAlignment(gfx::ALIGN_LEFT);
@@ skipping 23 matching lines @@
   }
 
   virtual ~NetworkMessageView() {
   }
 
   // Overridden from views::LinkListener.
   virtual void LinkClicked(views::Link* source, int event_flags) OVERRIDE {
     tray_network_->LinkClicked(message_type_, source->id());
   }
 
-  TrayNetwork::MessageType message_type() const { return message_type_; }
-  TrayNetwork::NetworkType network_type() const { return network_type_; }
+  NetworkObserver::MessageType message_type() const { return message_type_; }
+  NetworkObserver::NetworkType network_type() const { return network_type_; }
 
  private:
   TrayNetwork* tray_network_;
-  TrayNetwork::MessageType message_type_;
-  TrayNetwork::NetworkType network_type_;
+  NetworkObserver::MessageType message_type_;
+  NetworkObserver::NetworkType network_type_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkMessageView);
 };
 
 class NetworkNotificationView : public TrayNotificationView {
  public:
   explicit NetworkNotificationView(TrayNetwork* tray_network)
       : TrayNotificationView(tray_network, 0),
         tray_network_(tray_network) {
     CreateMessageView();
@@ skipping 132 matching lines @@
 void TrayNetwork::OnNetworkRefresh(const NetworkIconInfo& info) {
   if (tray_)
     tray_->Update(info);
   if (default_)
     default_->Update();
   if (detailed_)
     detailed_->ManagerChanged();
 }
 
 void TrayNetwork::SetNetworkMessage(NetworkTrayDelegate* delegate,
-                                   MessageType message_type,
-                                   NetworkType network_type,
-                                   const string16& title,
-                                   const string16& message,
-                                   const std::vector<string16>& links) {
+                                    MessageType message_type,
+                                    NetworkType network_type,
+                                    const string16& title,
+                                    const string16& message,
+                                    const std::vector<string16>& links) {
   messages_->messages()[message_type] = tray::NetworkMessages::Message(
       delegate, network_type, title, message, links);
   if (notification_)
     notification_->Update();
   else
     ShowNotificationView();
 }
 
 void TrayNetwork::ClearNetworkMessage(MessageType message_type) {
   messages_->messages().erase(message_type);
@@ skipping 96 matching lines @@
   // Get icon and label for connected or connecting network.
   *image = network_icon::GetImageForNetwork(network, icon_type);
   if (label)
     *label = network_icon::GetLabelForNetwork(network, icon_type);
 }
 
 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);
+    iter->second.delegate->NotificationLinkClicked(message_type, link_id);
 }
 
 }  // namespace internal
 }  // namespace ash