[CrOS Tether] Sort Tether network lists.

chromeos/network/network_state_handler.h

 // 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.
 
 #ifndef CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_
 #define CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_
 
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 51 matching lines @@
 //   the initial properties are received. The GUID will be consistent for
 //   the duration of a session, even if the network drops out and returns.
 
 class CHROMEOS_EXPORT NetworkStateHandler
     : public internal::ShillPropertyHandler::Listener {
  public:
   typedef std::vector<std::unique_ptr<ManagedState>> ManagedStateList;
   typedef std::vector<const NetworkState*> NetworkStateList;
   typedef std::vector<const DeviceState*> DeviceStateList;
 
+  class TetherSortDelegate {
+   public:
+    // Sorts |tether_networks| according to the Tether component rules.
+    // |tether_networks| contains only networks of type Tether.
+    virtual void SortTetherNetworkList(
+        ManagedStateList* tether_networks) const = 0;
+  };
+
   enum TechnologyState {
     TECHNOLOGY_UNAVAILABLE,
     TECHNOLOGY_AVAILABLE,
     TECHNOLOGY_UNINITIALIZED,
     TECHNOLOGY_ENABLING,
     TECHNOLOGY_ENABLED,
     TECHNOLOGY_PROHIBITED
   };
 
   ~NetworkStateHandler() override;
@@ skipping 101 matching lines @@
   // |visible_only| - if true only include networks in the visible Services list
   // |limit| - if > 0 limits the number of results.
   // The returned list contains a copy of NetworkState pointers which should not
   // be stored or used beyond the scope of the calling function (i.e. they may
   // later become invalid, but only on the UI thread). SortNetworkList() will be
   // called if necessary to provide the states in a convenient order (see
   // SortNetworkList for details).
   void GetNetworkListByType(const NetworkTypePattern& type,
                             bool configured_only,
                             bool visible_only,
-                            int limit,
+                            size_t limit,
                             NetworkStateList* list);
 
   // Finds and returns the NetworkState associated with |service_path| or NULL
   // if not found. If |configured_only| is true, only returns saved entries
   // (IsInProfile is true).
   const NetworkState* GetNetworkStateFromServicePath(
       const std::string& service_path,
       bool configured_only) const;
 
   // Finds and returns the NetworkState associated with |guid| or NULL if not
@@ skipping 56 matching lines @@
   void SetTetherNetworkStateDisconnected(const std::string& guid);
 
   // Set the connection_state of the Tether NetworkState corresponding to the
   // provided |guid| to "Connecting". This will be reflected in the UI.
   void SetTetherNetworkStateConnecting(const std::string& guid);
 
   // Set the connection_state of the Tether NetworkState corresponding to the
   // provided |guid| to "Connected". This will be reflected in the UI.
   void SetTetherNetworkStateConnected(const std::string& guid);
 
+  void set_tether_sort_delegate(
+      const TetherSortDelegate* tether_sort_delegate) {
+    tether_sort_delegate_ = tether_sort_delegate;
+  }
+
   // Sets |list| to contain the list of devices.  The returned list contains
   // a copy of DeviceState pointers which should not be stored or used beyond
   // the scope of the calling function (i.e. they may later become invalid, but
   // only on the UI thread).
   void GetDeviceList(DeviceStateList* list) const;
 
   // Like GetDeviceList() but only returns networks with matching |type|.
   void GetDeviceListByType(const NetworkTypePattern& type,
                            DeviceStateList* list) const;
 
@@ skipping 182 matching lines @@
   void NotifyScanCompleted(const DeviceState* device);
 
   // Returns one technology type for |type|. This technology will be the
   // highest priority technology in the type pattern.
   std::string GetTechnologyForType(const NetworkTypePattern& type) const;
 
   // Returns all the technology types for |type|.
   std::vector<std::string> GetTechnologiesForType(
       const NetworkTypePattern& type) const;
 
-  // Sets |list| to contain the list of Tether networks. If |limit| > 0, that
-  // will determine the number of results; pass 0 for no limit. The returned
-  // list contains a copy of NetworkState pointers which should not be stored or
-  // used beyond the scope of the calling function (i.e. they may later become
-  // invalid, but only on the UI thread).
-  // NOTE: See AddTetherNetworkState for more information about Tether networks.
-  void GetTetherNetworkList(int limit, NetworkStateList* list);
+  // Adds Tether networks to |list|, limiting the maximum size of |list| to be
+  // |limit|. If |get_active| is true, only active (i.e., connecting/connected)
+  // networks will be added; otherwise, only inactive networks will be added.
+  // The returned list contains a copy of NetworkState pointers which
+  // should not be stored or used beyond the scope of the calling
+  // function (i.e., they may later become invalid, but only on the UI thread).
+  // See AddTetherNetworkState() for more information about Tether networks.
+  void AppendTetherNetworksToList(bool get_active,
+                                  size_t limit,
+                                  NetworkStateList* list);
 
   // Set the connection_state of a Tether NetworkState corresponding to the
   // provided |guid|.
   void SetTetherNetworkStateConnectionState(
       const std::string& guid,
       const std::string& connection_state);
 
   // Ensures that the Tether DeviceState is present in |device_list_| if
   // |tether_technology_state_| is not TECHNOLOGY_UNAVAILABLE and ensures that
   // it is not present in |device_list_| if it is TECHNOLOGY_UNAVAILABLE.
@@ skipping 27 matching lines @@
 
   // Map of network specifiers to guids. Contains an entry for each
   // NetworkState that is not saved in a profile.
   SpecifierGuidMap specifier_guid_map_;
 
   // The state corresponding to the Tether device type. This value is managed by
   // the Tether component.
   TechnologyState tether_technology_state_ =
       TechnologyState::TECHNOLOGY_UNAVAILABLE;
 
+  // Not owned by this instance.
+  const TetherSortDelegate* tether_sort_delegate_ = nullptr;
+
   // Ensure that Shutdown() gets called exactly once.
   bool did_shutdown_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_