Support badges and connecting animation in cr-network-icon element

chromeos/dbus/fake_shill_manager_client.cc

 // Copyright 2013 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 "chromeos/dbus/fake_shill_manager_client.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 87 matching lines @@
          state == shill::kStateReady;
 }
 
 void UpdatePortaledWifiState(const std::string& service_path) {
   DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()
       ->SetServiceProperty(service_path,
                            shill::kStateProperty,
                            base::StringValue(shill::kStatePortal));
 }
 
+bool IsCellularTechnology(const std::string& type) {
+  return (type == shill::kNetworkTechnology1Xrtt ||
+          type == shill::kNetworkTechnologyEvdo ||
+          type == shill::kNetworkTechnologyGsm ||
+          type == shill::kNetworkTechnologyGprs ||
+          type == shill::kNetworkTechnologyEdge ||
+          type == shill::kNetworkTechnologyUmts ||
+          type == shill::kNetworkTechnologyHspa ||
+          type == shill::kNetworkTechnologyHspaPlus ||
+          type == shill::kNetworkTechnologyLte ||
+          type == shill::kNetworkTechnologyLteAdvanced);
+}
+
 const char* kTechnologyUnavailable = "unavailable";
 const char* kNetworkActivated = "activated";
 const char* kNetworkDisabled = "disabled";
 const char* kCellularServicePath = "/service/cellular1";
 const char* kRoamingRequired = "required";
 
 }  // namespace
 
 // static
 const char FakeShillManagerClient::kFakeEthernetNetworkGuid[] = "eth1_guid";
 
 FakeShillManagerClient::FakeShillManagerClient()
     : interactive_delay_(0),
+      cellular_technology_(shill::kNetworkTechnologyGsm),
       weak_ptr_factory_(this) {
   ParseCommandLineSwitch();
 }
 
 FakeShillManagerClient::~FakeShillManagerClient() {}
 
 // ShillManagerClient overrides.
 
 void FakeShillManagerClient::Init(dbus::Bus* bus) {}
 
@@ skipping 644 matching lines @@
                                  shill::kProviderRequiresRoamingProperty,
                                  base::FundamentalValue(true));
     }
 
     services->AddService(kCellularServicePath,
                          "cellular1_guid",
                          "cellular1" /* name */,
                          shill::kTypeCellular,
                          state,
                          add_to_visible);
-    base::StringValue technology_value(shill::kNetworkTechnologyGsm);
+    base::StringValue technology_value(cellular_technology_);
     devices->SetDeviceProperty("/device/cellular1",
                                shill::kTechnologyFamilyProperty,
                                technology_value);
     services->SetServiceProperty(kCellularServicePath,
                                  shill::kNetworkTechnologyProperty,
                                  technology_value);
 
     if (activated) {
       services->SetServiceProperty(
           kCellularServicePath,
@@ skipping 269 matching lines @@
     // "home", "roaming", or "required"
     roaming_state_ = arg1;
     return true;
   }
   return SetInitialNetworkState(arg0, arg1);
 }
 
 bool FakeShillManagerClient::SetInitialNetworkState(std::string type_arg,
                                                     std::string state_arg) {
   std::string state;
-  state_arg = base::StringToLowerASCII(state_arg);
   if (state_arg.empty() || state_arg == "1" || state_arg == "on" ||
       state_arg == "enabled" || state_arg == "connected" ||
       state_arg == "online") {
     // Enabled and connected (default value)
     state = shill::kStateOnline;
   } else if (state_arg == "0" || state_arg == "off" ||
              state_arg == "inactive" || state_arg == shill::kStateIdle) {
     // Technology enabled, services are created but are not connected.
     state = shill::kStateIdle;
   } else if (state_arg == "disabled" || state_arg == "disconnect") {
     // Technology disabled but available, services created but not connected.
     state = kNetworkDisabled;
   } else if (state_arg == "none" || state_arg == "offline") {
     // Technology not available, do not create services.
     state = kTechnologyUnavailable;
   } else if (state_arg == "portal") {
     // Technology is enabled, a service is connected and in Portal state.
     state = shill::kStatePortal;
   } else if (state_arg == "active" || state_arg == "activated") {
     // Technology is enabled, a service is connected and Activated.
     state = kNetworkActivated;
+  } else if (type_arg == shill::kTypeCellular &&
+             IsCellularTechnology(state_arg)) {
+    state = shill::kStateOnline;
+    cellular_technology_ = state_arg;
+  } else if (type_arg == shill::kTypeCellular && state_arg == "LTEAdvanced") {
+    // Special case, Shill name contains a ' '.
+    state = shill::kStateOnline;
+    cellular_technology_ = shill::kNetworkTechnologyLteAdvanced;
   } else {
-    LOG(ERROR) << "Unrecognized initial state: " << state_arg;
+    LOG(ERROR) << "Unrecognized initial state: " << type_arg << "="
+               << state_arg;
     return false;
   }
 
-  type_arg = base::StringToLowerASCII(type_arg);
   // Special cases
   if (type_arg == "wireless") {
     shill_initial_state_map_[shill::kTypeWifi] = state;
     shill_initial_state_map_[shill::kTypeCellular] = state;
     return true;
   }
   // Convenience synonyms.
   if (type_arg == "eth")
     type_arg = shill::kTypeEthernet;
 
@@ skipping 33 matching lines @@
   *enabled = true;
   if ((state == shill::kStatePortal && type != shill::kTypeWifi) ||
       (state == kNetworkActivated && type != shill::kTypeCellular)) {
     LOG(WARNING) << "Invalid state: " << state << " for " << type;
     return shill::kStateIdle;
   }
   return state;
 }
 
 }  // namespace chromeos