| // Copyright 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 CHROME_BROWSER_NET_NETWORK_STATS_H_ |
| #define CHROME_BROWSER_NET_NETWORK_STATS_H_ |
| |
| #include <bitset> |
| #include <string> |
| #include <vector> |
| |
| #include "base/memory/scoped_ptr.h" |
| #include "base/metrics/histogram.h" |
| #include "base/time/time.h" |
| #include "chrome/browser/io_thread.h" |
| #include "chrome/browser/net/probe_message.h" |
| #include "net/base/address_list.h" |
| #include "net/base/completion_callback.h" |
| #include "net/base/host_port_pair.h" |
| #include "net/base/io_buffer.h" |
| #include "net/proxy/proxy_info.h" |
| |
| namespace net { |
| class ClientSocketFactory; |
| class DatagramClientSocket; |
| class HostResolver; |
| class SingleRequestHostResolver; |
| } |
| |
| namespace chrome_browser_net { |
| |
| // This class is used for live experiment of network connectivity (for UDP) |
| // metrics. A small percentage of users participate in this experiment. All |
| // users (who are in the experiment) must have enabled "UMA upload". |
| // In the experiments, clients request the server to send some probing packets, |
| // collect some stats, and send back the results via UMA reports. |
| // |
| // This class collects the following stats from users who have opted in. |
| // a) RTT. |
| // b) packet inter-arrival time. |
| // c) packet losses for correlation and FEC experiments. |
| // d) packet losses for NAT binding test after idling for a certain period. |
| // |
| // There are three tests in one experiment. Right before each test, a |
| // HelloRequest is sent to get an updated token. |
| // 1. |START_PACKET_TEST|: 21 packets are sent from the server to the client |
| // without pacing. |
| // 2. |PACED_PACKET_TEST| or |NON_PACED_PACKET_TEST|: After the first test, |
| // 21 packets are sent from the server to the client with or without pacing. |
| // If pacing, the pacing rate is computed from the first test. |
| // 3. |NAT_BIND_TEST|: 2 packets are sent from the server to the client with |
| // a randomly generated delay of 1~300 seconds. |
| // At the end of these tests, we send another HelloRequest to test whether |
| // the network is still connected and has not changed (e.g. from Wifi to 3g). |
| |
| class NetworkStats { |
| public: |
| enum Status { // Used in HISTOGRAM_ENUMERATION. |
| SUCCESS, // Successfully received bytes from the server. |
| SOCKET_CREATE_FAILED, // Socket creation failed. |
| RESOLVE_FAILED, // Host resolution failed. |
| CONNECT_FAILED, // Connection to the server failed. |
| WRITE_FAILED, // Sending a message to the server failed. |
| READ_TIMED_OUT, // Reading the reply from the server timed out. |
| READ_FAILED, // Reading the reply from the server failed. |
| STATUS_MAX, // Bounding value. |
| }; |
| |
| enum ReadState { // Used to track if |socket_| has a pending read. |
| READ_STATE_IDLE, |
| READ_STATE_READ_PENDING, |
| }; |
| |
| enum WriteState { // Used to track if |socket_| has a pending write. |
| WRITE_STATE_IDLE, |
| WRITE_STATE_WRITE_PENDING, |
| }; |
| |
| // |TestType| specifies the possible tests we may run |
| // (except for the first and the last serving as boundaries). |
| enum TestType { |
| // The first one is for requesting token, not a probe test. Put it here |
| // because we use it as a symbol for sending the HelloRequest packet to |
| // acquire the token. |
| TOKEN_REQUEST, |
| START_PACKET_TEST, // First packet loss test (no pacing). |
| NON_PACED_PACKET_TEST, // Packet loss test with no pacing. |
| PACED_PACKET_TEST, // Packet loss test with pacing. |
| // Test whether NAT binding expires after some idle period. |
| NAT_BIND_TEST, |
| PACKET_SIZE_TEST, |
| TEST_TYPE_MAX, |
| }; |
| |
| // Pointer |socket_factory| is NOT deleted by this class. |
| explicit NetworkStats(net::ClientSocketFactory* socket_factory); |
| // NetworkStats is deleted in TestPhaseComplete() when all tests are done. |
| ~NetworkStats(); |
| |
| // Start the client and connect to |server|. |
| // A client will request a token and then perform several tests. |
| // When the client finishes all tests, or when an error occurs causing the |
| // client to stop, |TestPhaseComplete| will be called with a net status code. |
| // |TestPhaseComplete| will collect histogram stats. |
| // Return true if successful in starting the client. |
| bool Start(net::HostResolver* host_resolver, |
| const net::HostPortPair& server, |
| uint16 histogram_port, |
| bool has_proxy_server, |
| uint32 probe_bytes, |
| uint32 bytes_for_packet_size_test, |
| const net::CompletionCallback& callback); |
| |
| private: |
| friend class NetworkStatsTest; |
| |
| // Start the test specified by the current_test_index_. It also resets all |
| // the book keeping data, before starting the new test. |
| void StartOneTest(); |
| |
| // Reset all the counters and the collected stats. |
| void ResetData(); |
| |
| // Callback that is called when host resolution is completed. |
| void OnResolveComplete(int result); |
| |
| // Called after host is resolved. Creates UDPClientSocket and connects to the |
| // server. If successfully connected, then calls ConnectComplete() to start |
| // the network connectivity tests. Returns |false| if there is any error. |
| bool DoConnect(int result); |
| |
| // This method is called after socket connection is completed. It will start |
| // the process of sending packets to |server| by calling SendHelloPacket(). |
| // Return false if connection is not established (result is less than 0). |
| bool ConnectComplete(int result); |
| |
| // Send a HelloRequest packet which asks for a token from the server. If |
| // a token is received, it will will add |START_PACKET_TEST| to the test |
| // queue. |
| void SendHelloRequest(); |
| |
| // Send a ProbeRequest packet which requests the server to send a set |
| // of Probing packets. |
| void SendProbeRequest(); |
| |
| // Read and process the data. Called from OnReadComplete() or ReadData(). |
| // This function calls TestPhaseComplete() if there is a significant network |
| // error or if all packets in the current test are received. |
| // Return true if TestPhaseComplete() is called otherwise return false. |
| bool ReadComplete(int result); |
| |
| // Callbacks when an internal IO (Read or Write) is completed. |
| void OnReadComplete(int result); |
| void OnWriteComplete(int result); |
| |
| // Read data from server until an error or IO blocking occurs or reading is |
| // complete. Return the result value from socket reading and 0 if |socket_| |
| // is Null. |
| int ReadData(); |
| |
| // Send data contained in |str| to server. |
| // Return a negative value if IO blocking occurs or there is an error. |
| // Otherwise return net::OK. |
| int SendData(const std::string& str); |
| |
| // Update the send buffer (telling it that |bytes_sent| has been sent). |
| // And reset |write_buffer_|. |
| void UpdateSendBuffer(int bytes_sent); |
| |
| // Start a timer (with value |milliseconds|) for responses from the probe |
| // servers. |test_index| is the index of the test at vector |test_sequence_| |
| // and it is used as a parameter of the timer callback. |
| void StartReadDataTimer(uint32 milliseconds, uint32 test_index); |
| |
| // Called when the StartReadDataTimer fires. |test_index| specifies |
| // the index of the test. If |current_test_index_| has changed to a |
| // different value, it indicates |test_index| has completed, then |
| // this method is a no-op. |
| void OnReadDataTimeout(uint32 test_index); |
| |
| // Collect network connectivity stats. This is called when all the data from |
| // server is read or when there is a failure during connect/read/write. It |
| // will either start the next phase of the test, or it will self destruct |
| // at the end of this method. Returns true if a new test wasn't started and it |
| // was self destructed. |
| bool TestPhaseComplete(Status status, int result); |
| |
| // This method is called from TestPhaseComplete() and calls |
| // |finished_callback_| callback to indicate that the test has finished. |
| void DoFinishCallback(int result); |
| |
| // Update counters/metrics for the given |probe_packet|. |
| // Return true if all packets for the current test are received and |
| // false otherwise. |
| bool UpdateReception(const ProbePacket& probe_packet); |
| |
| // Record all histograms for current test phase, which is assumed to be |
| // complete (i.e., we are no longer waiting for packets in this phase). |
| // |test_type| is the current test_type to be recorded. |status| is the |
| // status of the current test. |
| void RecordHistograms(TestType test_type); |
| |
| // Collect the following network connectivity stats when |
| // kMaximumSequentialPackets (21) packets are sent from the server. |
| // a) Client received at least one packet. |
| // b) Client received the nth packet. |
| // c) The number of packets received for each subsequence of packets 1...n. |
| void RecordPacketsReceivedHistograms(TestType test_type); |
| |
| // Collect the following network connectivity stats for the first |
| // kMaximumCorrelationPackets (6) packets in a test. |
| // Success/failure of each packet, to estimate reachability for users, |
| // and to estimate if there is a probabalistic dependency in packet loss when |
| // kMaximumCorrelationPackets packets are sent consecutively. |
| void RecordPacketLossSeriesHistograms(TestType test_type); |
| |
| // Collect the average inter-arrival time (scaled up by 20 times because the |
| // minimum time value in a histogram is 1ms) of a sequence of probing packets. |
| void RecordInterArrivalHistograms(TestType test_type); |
| |
| // Collect the RTT for the packet specified by the |index| in the current |
| // test. |
| void RecordRTTHistograms(TestType test_type, uint32 index); |
| |
| // Collect whether the second packet in the NAT test is received for the |
| // given idle time. |
| void RecordNATTestReceivedHistograms(Status status); |
| |
| // Collect whether we have the requested packet size was received or not in |
| // the PACKET_SIZE_TEST test. |
| void RecordPacketSizeTestReceivedHistograms(Status status); |
| |
| // Record the time duration between sending the probe request and receiving |
| // the last probe packet excluding the pacing time requested by the client. |
| // This applies to both NAT bind test and paced/non-paced packet test. |
| void RecordSendToLastRecvDelayHistograms(TestType test_type); |
| |
| // Return the next test type (internally increment |current_test_index_|) |
| // in |test_sequence_|; |
| TestType GetNextTest(); |
| |
| // These static variables are defined so that they can be changed in testing. |
| // Maximum number of tests in one activation of the experiment. |
| static uint32 maximum_tests_; |
| // Maximum number of packets for START/PACED/NON_PACED tests. |
| static uint32 maximum_sequential_packets_; |
| // Maximum number of packets for NAT binding test. |
| static uint32 maximum_NAT_packets_; |
| // Maximum time duration between the two packets for NAT Bind testing. |
| static uint32 maximum_NAT_idle_seconds_; |
| // Whether to start the probe test immediately after connect success. |
| // Used for unittest. |
| static bool start_test_after_connect_; |
| |
| // The socket handler for this session. |
| scoped_ptr<net::DatagramClientSocket> socket_; |
| |
| net::ClientSocketFactory* socket_factory_; |
| |
| // The read buffer used to read data from the socket. |
| scoped_refptr<net::IOBuffer> read_buffer_; |
| |
| // The write buffer used to write data to the socket. |
| scoped_refptr<net::DrainableIOBuffer> write_buffer_; |
| |
| // Specify the port for which we are testing the network connectivity. |
| uint16 histogram_port_; |
| |
| // Specify if there is a proxy server or not. |
| bool has_proxy_server_; |
| |
| // HostResolver used to find the IP addresses. |
| scoped_ptr<net::SingleRequestHostResolver> resolver_; |
| |
| // Addresses filled out by HostResolver after host resolution is completed. |
| net::AddressList addresses_; |
| |
| // Callback to call when test is successefully finished or whenever |
| // there is an error (this will be used by unittests to check the result). |
| net::CompletionCallback finished_callback_; |
| |
| // RTTs for each packet. |
| std::vector<base::TimeDelta> packet_rtt_; |
| |
| // Time when sending probe_request, used for computing RTT. |
| base::TimeTicks probe_request_time_; |
| |
| // Size of the probe packets requested to be sent from servers. We don't use |
| // |probe_packet_bytes_| during PACKET_SIZE_TEST. |
| uint32 probe_packet_bytes_; |
| |
| // Size of the packet requested to be sent from servers for PACKET_SIZE_TEST. |
| uint32 bytes_for_packet_size_test_; |
| |
| // bitmask indicating which packets are received. |
| std::bitset<21> packets_received_mask_; |
| |
| // Arrival time of the first packet in the current test. |
| base::TimeTicks first_arrival_time_; |
| // Arrival time of the most recently received packet in the current test. |
| base::TimeTicks last_arrival_time_; |
| // Average time between two consecutive packets. It is updated when either all |
| // packets are received or timeout happens in the current test. |
| base::TimeDelta inter_arrival_time_; |
| // Target time duration for sending two consecutive packets at the server. |
| // It should be 0 for StartPacket test or NonPacedPacket test. For |
| // PacedPacket test, it is derived from the inter_arrival_time_ in the |
| // previous (StartPacket) test. For NATBind test, it is randomly generated |
| // between 1 second and |maximum_NAT_idle_seconds_| seconds. |
| base::TimeDelta pacing_interval_; |
| // A list of tests that will be performed in sequence. |
| std::vector<TestType> test_sequence_; |
| uint32 current_test_index_; // Index of the current test. |
| |
| ProbeMessage probe_message_; |
| |
| // Token received from server for authentication. |
| ProbePacket_Token token_; |
| |
| // The state variables to track pending reads/writes. |
| ReadState read_state_; |
| WriteState write_state_; |
| |
| // We use this factory to create timeout tasks for socket's ReadData. |
| base::WeakPtrFactory<NetworkStats> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(NetworkStats); |
| }; |
| |
| class ProxyDetector { |
| public: |
| // Used for the callback that is called from |OnResolveProxyComplete|. |
| typedef base::Callback<void(bool)> OnResolvedCallback; |
| |
| // Construct a ProxyDetector object that finds out if access to |
| // |server_address| goes through a proxy server or not. Calls the |callback| |
| // after proxy resolution is completed by currying the proxy resolution |
| // status. |
| ProxyDetector(net::ProxyService* proxy_service, |
| const net::HostPortPair& server_address, |
| OnResolvedCallback callback); |
| |
| // This method uses |proxy_service_| to resolve the proxy for |
| // |server_address_|. |
| void StartResolveProxy(); |
| |
| private: |
| // This object is deleted from |OnResolveProxyComplete|. |
| ~ProxyDetector(); |
| |
| // Call the |callback_| by currying the proxy resolution status. |
| void OnResolveProxyComplete(int result); |
| |
| // |proxy_service_| specifies the proxy service that is to be used to find |
| // if access to |server_address_| goes through proxy server or not. |
| net::ProxyService* proxy_service_; |
| |
| // |server_address_| specifies the server host and port pair for which we are |
| // trying to see if access to it, goes through proxy or not. |
| net::HostPortPair server_address_; |
| |
| // |callback_| will be called after proxy resolution is completed. |
| OnResolvedCallback callback_; |
| |
| // |proxy_info_| holds proxy information returned by ResolveProxy. |
| net::ProxyInfo proxy_info_; |
| |
| // Indicate if there is a pending a proxy resolution. We use this to assert |
| // that there is no in-progress proxy resolution request. |
| bool has_pending_proxy_resolution_; |
| DISALLOW_COPY_AND_ASSIGN(ProxyDetector); |
| }; |
| |
| // This collects the network connectivity stats for UDP protocol for small |
| // percentage of users who are participating in the experiment (by enabling |
| // "UMA upload"). This method gets called only if UMA upload to the |
| // server has succeeded. |
| void CollectNetworkStats(const std::string& network_stats_server_url, |
| IOThread* io_thread); |
| |
| // This starts a series of tests randomly selected among one of the three |
| // choices of probe packet sizes: 100 Bytes, 500 Bytes, 1200 Bytes. |
| void StartNetworkStatsTest(net::HostResolver* host_resolver, |
| const net::HostPortPair& server_address, |
| uint16 histogram_port, |
| bool has_proxy_server); |
| |
| } // namespace chrome_browser_net |
| |
| #endif // CHROME_BROWSER_NET_NETWORK_STATS_H_ |