Move chromeos code to namespace chromeos.

chrome/browser/chromeos/network_library.h

 // Copyright (c) 2009 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 CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
-#define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
+#ifndef CHROME_BROWSER_CHROMEOS_NETWORK_LIBRARY_H_
+#define CHROME_BROWSER_CHROMEOS_NETWORK_LIBRARY_H_
 
 #include <string>
 #include <vector>
 
 #include "base/observer_list.h"
 #include "base/platform_thread.h"
 #include "base/singleton.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "net/url_request/url_request_job_tracker.h"
 #include "third_party/cros/chromeos_network.h"
 
+namespace chromeos {
+
 struct WifiNetwork {
   WifiNetwork()
       : encrypted(false),
         encryption(chromeos::NONE),
         strength(0),
         connecting(false),
         connected(false),
         destroyed(false) {}
   WifiNetwork(const std::string& ssid, bool encrypted,
               chromeos::EncryptionType encryption, int strength,
@@ skipping 16 matching lines @@
   chromeos::EncryptionType encryption;
   int strength;
   bool connecting;
   bool connected;
   bool destroyed;
 };
 typedef std::vector<WifiNetwork> WifiNetworkVector;
 
 // This class handles the interaction with the ChromeOS network library APIs.
 // Classes can add themselves as observers. Users can get an instance of this
-// library class like this: CrosNetworkLibrary::Get()
-class CrosNetworkLibrary : public URLRequestJobTracker::JobObserver {
+// library class like this: NetworkLibrary::Get()
+class NetworkLibrary : public URLRequestJobTracker::JobObserver {
  public:
   class Observer {
    public:
     // A bitfield mask for traffic types.
     enum TrafficTypes {
       TRAFFIC_DOWNLOAD = 0x1,
       TRAFFIC_UPLOAD = 0x2,
     } TrafficTypeMasks;
 
     // Called when the network has changed. (wifi networks, and ethernet)
-    virtual void NetworkChanged(CrosNetworkLibrary* obj) = 0;
+    virtual void NetworkChanged(NetworkLibrary* obj) = 0;
 
     // Called when network traffic has been detected.
     // Takes a bitfield of TrafficTypeMasks.
-    virtual void NetworkTraffic(CrosNetworkLibrary* obj, int traffic_type) = 0;
+    virtual void NetworkTraffic(NetworkLibrary* obj, int traffic_type) = 0;
   };
 
-  // This gets the singleton CrosNetworkLibrary
-  static CrosNetworkLibrary* Get();
+  // This gets the singleton NetworkLibrary
+  static NetworkLibrary* Get();
 
   // Returns true if the ChromeOS library was loaded.
   static bool loaded();
 
   // URLRequestJobTracker::JobObserver methods (called on the IO thread):
   virtual void OnJobAdded(URLRequestJob* job);
   virtual void OnJobRemoved(URLRequestJob* job);
   virtual void OnJobDone(URLRequestJob* job, const URLRequestStatus& status);
   virtual void OnJobRedirect(URLRequestJob* job, const GURL& location,
                              int status_code);
   virtual void OnBytesRead(URLRequestJob* job, int byte_count);
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   bool ethernet_connected() const { return ethernet_connected_; }
   const std::string& wifi_ssid() const { return wifi_.ssid; }
   bool wifi_connecting() const { return wifi_.connecting; }
   int wifi_strength() const { return wifi_.strength; }
 
   // Returns the current list of wifi networks.
   const WifiNetworkVector& wifi_networks() const { return wifi_networks_; }
 
   // Connect to the specified wireless network with password.
   void ConnectToWifiNetwork(WifiNetwork network, const string16& password);
 
  private:
-  friend struct DefaultSingletonTraits<CrosNetworkLibrary>;
+  friend struct DefaultSingletonTraits<NetworkLibrary>;
 
-  CrosNetworkLibrary();
-  ~CrosNetworkLibrary();
+  NetworkLibrary();
+  ~NetworkLibrary();
 
   // This method is called when there's a change in network status.
   // This method is called on a background thread.
   static void NetworkStatusChangedHandler(void* object,
       const chromeos::ServiceStatus& service_status);
 
   // This parses ServiceStatus and creates a WifiNetworkVector of wifi networks.
   // It also sets ethernet_connected depending on if we have ethernet or not.
   static void ParseNetworks(const chromeos::ServiceStatus& service_status,
                             WifiNetworkVector* networks,
@@ skipping 24 matching lines @@
   // This will notify all obeservers on the UI thread.
   void NotifyObservers();
 
   ObserverList<Observer> observers_;
 
   // The amount of time to wait between each NetworkTraffic notifications.
   static const int kNetworkTrafficeTimerSecs;
 
   // Timer for sending NetworkTraffic notification every
   // kNetworkTrafficeTimerSecs seconds.
-  base::OneShotTimer<CrosNetworkLibrary> timer_;
+  base::OneShotTimer<NetworkLibrary> timer_;
 
   // The current traffic type that will be sent out for the next NetworkTraffic
   // notification. This is a bitfield of TrafficTypeMasks.
   int traffic_type_;
 
   // The network status connection for monitoring network status changes.
   chromeos::NetworkStatusConnection network_status_connection_;
 
   // Whether or not we are connected to the ethernet line.
   bool ethernet_connected_;
 
   // The list of available wifi networks.
   WifiNetworkVector wifi_networks_;
 
   // The current connected (or connecting) wifi network.
   WifiNetwork wifi_;
 
-  DISALLOW_COPY_AND_ASSIGN(CrosNetworkLibrary);
+  DISALLOW_COPY_AND_ASSIGN(NetworkLibrary);
 };
 
-#endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_NETWORK_LIBRARY_H_