Speak a message when accessibility is on and the network state changes

chrome/browser/chromeos/status/network_menu_icon.cc

 // Copyright (c) 2011 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/status/network_menu_icon.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/chromeos/accessibility_util.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/skbitmap_operations.h"
 
 using std::max;
 using std::min;
@@ skipping 179 matching lines @@
     const Network* network = cros->FindNetworkByPath(service_path_);
     if (!network) {
       // If not a visible network, check for a remembered network.
       network = cros->FindRememberedNetworkByPath(service_path_);
       if (!network) {
         LOG(WARNING) << "Unable to find network:" << service_path_;
         return;
       }
     }
     bool dirty = bitmap_.empty();
+    bool speak = false;
+    if ((Network::IsConnectedState(state_) && !network->connected()) ||
+        (Network::IsConnectingState(state_) && !network->connecting()) ||
+        (Network::IsDisconnectedState(state_) && !network->disconnected())) {
+      speak = true;
+    }
     if (state_ != network->state()) {
       state_ = network->state();
       dirty = true;
     }
     ConnectionType type = network->type();
     if (type == TYPE_WIFI || type == TYPE_CELLULAR) {
       int index = 0;
       if (type == TYPE_WIFI) {
         index = WifiStrengthIndex(
             static_cast<const WifiNetwork*>(network));
@@ skipping 20 matching lines @@
     if (type == TYPE_VPN) {
       if (cros->connected_network() != connected_network_) {
         connected_network_ = cros->connected_network();
         dirty = true;
       }
     }
     if (dirty) {
       UpdateIcon(network);
       GenerateBitmap();
     }
+    if (speak) {
+      std::string connection_string;
+      if (Network::IsConnectedState(state_)) {
+        switch (network->type()) {
+          case TYPE_ETHERNET:
+            connection_string = l10n_util::GetStringFUTF8(
+                IDS_STATUSBAR_NETWORK_CONNECTED_TOOLTIP,
+                l10n_util::GetStringUTF16(
+                    IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET));
+            break;
+          default:
+            connection_string = l10n_util::GetStringFUTF8(
+                IDS_STATUSBAR_NETWORK_CONNECTED_TOOLTIP,
+                UTF8ToUTF16(network->name()));
+            break;
+        }
+      } else if (Network::IsConnectingState(state_)) {
+        const Network* connecting_network = cros->connecting_network();
+        if (connecting_network && connecting_network->type() != TYPE_ETHERNET) {
+          connection_string = l10n_util::GetStringFUTF8(
+              IDS_STATUSBAR_NETWORK_CONNECTING_TOOLTIP,
+              UTF8ToUTF16(connecting_network->name()));
+        }
+      } else if (Network::IsDisconnectedState(state_)) {
+        connection_string =  l10n_util::GetStringUTF8(
+            IDS_STATUSBAR_NETWORK_NO_NETWORK_TOOLTIP);
+      }
+      if (!connection_string.empty()) {
+        accessibility::MaybeSpeak(connection_string.c_str(), true, false);
+      }
+    }
   }
 
   // Sets up the base icon image.
   void SetIcon(const Network* network) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
     switch (network->type()) {
       case TYPE_ETHERNET: {
         icon_ = *rb.GetBitmapNamed(IDR_STATUSBAR_WIRED);
         break;
@@ skipping 497 matching lines @@
 
 const SkBitmap NetworkMenuIcon::GetConnectedBitmap(BitmapType type) {
   return GetBitmap(type, NumBitmaps(type) - 1);
 }
 
 int NetworkMenuIcon::NumBitmaps(BitmapType type) {
   return (type == ARCS) ? kNumArcsImages : kNumBarsImages;
 }
 
 }  // chromeos