[CrOS Tether] Add tether network properties (battery percentage, carrier, and signal strength) to t…

chromeos/network/network_state_handler.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 "chromeos/network/network_state_handler.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
-#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler_observer.h"
+#include "chromeos/network/tether_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 bool ConnectionStateChanged(NetworkState* network,
                             const std::string& prev_connection_state,
                             bool prev_is_captive_portal) {
   return ((network->connection_state() != prev_connection_state) &&
@@ skipping 252 matching lines @@
   GetVisibleNetworkListByType(NetworkTypePattern::Default(), list);
 }
 
 void NetworkStateHandler::GetNetworkListByType(const NetworkTypePattern& type,
                                                bool configured_only,
                                                bool visible_only,
                                                int limit,
                                                NetworkStateList* list) {
   DCHECK(list);
   list->clear();
-  int count = 0;
+
+  if (type.MatchesPattern(NetworkTypePattern::Tether())) {
+    GetTetherNetworkList(limit, list);
+  }
+
+  int count = list->size();
+
+  if (type.Equals(NetworkTypePattern::Tether()) ||
+      (limit != 0 && count >= limit)) {
+    // If only searching for tether networks, there is no need to continue
+    // searching through other network types; likewise, if the limit has already
+    // been reached, there is no need to continue searching.
+    return;
+  }
+
   // Sort the network list if necessary.
   if (!network_list_sorted_)
     SortNetworkList();
   for (auto iter = network_list_.begin(); iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
     if (!network->update_received() || !network->Matches(type))
       continue;
     if (configured_only && !network->IsInProfile())
       continue;
@@ skipping 48 matching lines @@
   // If the network already exists, do nothing.
   if (GetNetworkStateFromGuid(guid)) {
     NET_LOG(ERROR) << "AddTetherNetworkState: " << name
                    << " called with existing guid:" << guid;
     return;
   }
 
   std::unique_ptr<NetworkState> tether_network_state =
       base::MakeUnique<NetworkState>(guid);
 
+  // Tether networks are always connectable
+  tether_network_state->connectable_ = true;
   tether_network_state->set_name(name);
   tether_network_state->set_type(kTypeTether);
   tether_network_state->SetGuid(guid);
   tether_network_state->set_visible(true);
   tether_network_state->set_update_received();
 
   tether_network_list_.push_back(std::move(tether_network_state));
   NotifyNetworkListChanged();
 }
 
@@ skipping 188 matching lines @@
                       service_path.c_str()));
     return nullptr;
   }
   return list.front();
 }
 
 void NetworkStateHandler::SetLastErrorForTest(const std::string& service_path,
                                               const std::string& error) {
   NetworkState* network_state = GetModifiableNetworkState(service_path);
   if (!network_state) {
-    LOG(ERROR) << "No matching NetworkState for: " << service_path;
+    NET_LOG(ERROR) << "No matching NetworkState for: " << service_path;
     return;
   }
   network_state->last_error_ = error;
 }
 
 //------------------------------------------------------------------------------
 // ShillPropertyHandler::Delegate overrides
 
 void NetworkStateHandler::UpdateManagedList(ManagedState::ManagedType type,
                                             const base::ListValue& entries) {
@@ skipping 580 matching lines @@
   if (type.MatchesType(shill::kTypeBluetooth))
     technologies.emplace_back(shill::kTypeBluetooth);
   if (type.MatchesType(shill::kTypeVPN))
     technologies.emplace_back(shill::kTypeVPN);
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies;
 }
 
 }  // namespace chromeos