Clean up code by removing network traffic code in network library....

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2010 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/cros/network_library.h"
 
 #include <algorithm>
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
-#include "net/url_request/url_request_job.h"
 
 namespace chromeos {
 
 static const std::string kGoogleWifi = "Google";
 static const std::string kGoogleAWifi = "Google-A";
 
 // Helper function to wrap Html with <th> tag.
 static std::string WrapWithTH(std::string text) {
   return "<th>" + text + "</th>";
 }
@@ skipping 173 matching lines @@
     case SECURITY_RSN:
       return "RSN";
     case SECURITY_8021X:
       return "8021X";
   }
   return "Unknown";}
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkLibrary
 
-class NetworkLibraryImpl : public NetworkLibrary,
-                           public URLRequestJobTracker::JobObserver {
+class NetworkLibraryImpl : public NetworkLibrary  {
  public:
   NetworkLibraryImpl()
-      : traffic_type_(0),
-        network_status_connection_(NULL),
+      : network_status_connection_(NULL),
         available_devices_(0),
         enabled_devices_(0),
         connected_devices_(0),
         offline_mode_(false) {
     if (CrosLibrary::Get()->EnsureLoaded()) {
       Init();
     } else {
       InitTestData();
     }
-    g_url_request_job_tracker.AddObserver(this);
   }
 
   ~NetworkLibraryImpl() {
     if (network_status_connection_) {
       DisconnectMonitorNetwork(network_status_connection_);
     }
-    g_url_request_job_tracker.RemoveObserver(this);
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  // NetworkLibraryImpl, URLRequestJobTracker::JobObserver implementation:
-
-  void OnJobAdded(URLRequestJob* job) {
-    CheckNetworkTraffic(false);
-  }
-
-  void OnJobRemoved(URLRequestJob* job) {
-    CheckNetworkTraffic(false);
-  }
-
-  void OnJobDone(URLRequestJob* job, const URLRequestStatus& status) {
-    CheckNetworkTraffic(false);
-  }
-
-  void OnJobRedirect(
-      URLRequestJob* job, const GURL& location, int status_code) {
-    CheckNetworkTraffic(false);
-  }
-
-  void OnBytesRead(URLRequestJob* job, const char* buf, int byte_count) {
-    CheckNetworkTraffic(true);
   }
 
   void AddObserver(Observer* observer) {
     observers_.AddObserver(observer);
   }
 
   void RemoveObserver(Observer* observer) {
     observers_.RemoveObserver(observer);
   }
 
@@ skipping 640 matching lines @@
 
     available_devices_ = system->available_technologies;
     enabled_devices_ = system->enabled_technologies;
     connected_devices_ = system->connected_technologies;
     offline_mode_ = system->offline_mode;
 
     FOR_EACH_OBSERVER(Observer, observers_, NetworkChanged(this));
     FreeSystemInfo(system);
   }
 
-  void CheckNetworkTraffic(bool download) {
-    // If we already have a pending upload and download notification, then
-    // shortcut and return.
-    if (traffic_type_ ==
-        (Observer::TRAFFIC_DOWNLOAD | Observer::TRAFFIC_UPLOAD)) {
-      return;
-    }
-    // Figure out if we are uploading and/or downloading. We are downloading
-    // if download == true. We are uploading if we have upload progress.
-    if (download)
-      traffic_type_ |= Observer::TRAFFIC_DOWNLOAD;
-    if ((traffic_type_ & Observer::TRAFFIC_UPLOAD) == 0) {
-      URLRequestJobTracker::JobIterator it;
-      for (it = g_url_request_job_tracker.begin();
-           it != g_url_request_job_tracker.end();
-           ++it) {
-        URLRequestJob* job = *it;
-        if (job->GetUploadProgress() > 0) {
-          traffic_type_ |= Observer::TRAFFIC_UPLOAD;
-          break;
-        }
-      }
-    }
-    // If we have new traffic data to send out and the timer is not currently
-    // running, then start a new timer.
-    if (traffic_type_ && !timer_.IsRunning()) {
-      timer_.Start(base::TimeDelta::FromSeconds(kNetworkTrafficeTimerSecs),
-                   this,
-                   &NetworkLibraryImpl::NetworkTrafficTimerFired);
-    }
-  }
-
-  void  NetworkTrafficTimerFired() {
-    ChromeThread::PostTask(
-        ChromeThread::UI, FROM_HERE,
-        NewRunnableMethod(this, &NetworkLibraryImpl::NotifyNetworkTraffic,
-                          traffic_type_));
-    // Reset traffic type so that we don't send the same data next time.
-    traffic_type_ = 0;
-  }
-
-  void NotifyNetworkTraffic(int traffic_type) {
-    FOR_EACH_OBSERVER(Observer, observers_, NetworkTraffic(this, traffic_type));
-  }
-
   ObserverList<Observer> observers_;
 
-  // The amount of time to wait between each NetworkTraffic notifications.
-  static const int kNetworkTrafficeTimerSecs = 1;
-
-  // Timer for sending NetworkTraffic notification every
-  // kNetworkTrafficeTimerSecs seconds.
-  base::OneShotTimer<NetworkLibraryImpl> 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.
   MonitorNetworkConnection network_status_connection_;
 
   // The ethernet network.
   EthernetNetwork ethernet_;
 
   // The list of available wifi networks.
   WifiNetworkVector wifi_networks_;
 
   // The current connected (or connecting) wifi network.
@@ skipping 22 matching lines @@
 
   bool offline_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkLibraryImpl);
 };
 
 class NetworkLibraryStubImpl : public NetworkLibrary {
  public:
   NetworkLibraryStubImpl() : ip_address_("1.1.1.1") {}
   ~NetworkLibraryStubImpl() {}
-  void OnJobAdded(URLRequestJob* job) {}
-  void OnJobRemoved(URLRequestJob* job) {}
-  void OnJobDone(URLRequestJob* job, const URLRequestStatus& status) {}
-  void OnJobRedirect(
-      URLRequestJob* job, const GURL& location, int status_code) {}
-  void OnBytesRead(URLRequestJob* job, const char* buf, int byte_count) {}
   void AddObserver(Observer* observer) {}
   void RemoveObserver(Observer* observer) {}
   virtual const EthernetNetwork& ethernet_network() const {
     return ethernet_;
   }
   virtual bool ethernet_connecting() const { return false; }
   virtual bool ethernet_connected() const { return true; }
   virtual const std::string& wifi_name() const { return EmptyString(); }
   virtual bool wifi_connecting() const { return false; }
   virtual bool wifi_connected() const { return false; }
@@ skipping 75 matching lines @@
     return new NetworkLibraryStubImpl();
   else
     return new NetworkLibraryImpl();
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImpl);