Reduce the number of calls to external estimate provider

chrome/browser/android/net/external_estimate_provider_android_unittest.cc

 // Copyright 2015 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/android/net/external_estimate_provider_android.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/at_exit.h"
@@ skipping 28 matching lines @@
   TestNetworkQualityEstimator(
       std::unique_ptr<chrome::android::ExternalEstimateProviderAndroid>
           external_estimate_provider,
       const std::map<std::string, std::string>& variation_params)
       : NetworkQualityEstimator(std::move(external_estimate_provider),
                                 variation_params),
         notified_(false) {}
 
   ~TestNetworkQualityEstimator() override {}
 
-  void OnUpdatedEstimateAvailable() override {
+  void OnUpdatedEstimateAvailable(const base::TimeDelta& rtt,
+                                  int32_t downstream_throughput_kbps,
+                                  int32_t upstream_throughput_kbps) override {
+    EXPECT_EQ(base::TimeDelta(), rtt);
+    EXPECT_EQ(-1, downstream_throughput_kbps);
+    EXPECT_EQ(-1, upstream_throughput_kbps);
     notified_ = true;
-    net::NetworkQualityEstimator::OnUpdatedEstimateAvailable();
+    net::NetworkQualityEstimator::OnUpdatedEstimateAvailable(
+        rtt, downstream_throughput_kbps, upstream_throughput_kbps);
   }
 
-  bool IsNotified() const { return notified_; }
+  bool notified() const { return notified_; }
 
  private:
   bool notified_;
 };
 
 class TestExternalEstimateProviderAndroid
     : public chrome::android::ExternalEstimateProviderAndroid {
  public:
   TestExternalEstimateProviderAndroid()
       : chrome::android::ExternalEstimateProviderAndroid() {}
   ~TestExternalEstimateProviderAndroid() override {}
   using ExternalEstimateProviderAndroid::NotifyUpdatedEstimateAvailable;
 
   bool GetTimeSinceLastUpdate(
       base::TimeDelta* time_since_last_update) const override {
-    *time_since_last_update = base::TimeDelta::FromMilliseconds(1);
+    *time_since_last_update = base::TimeDelta::FromMilliseconds(0);
     return true;
   }
 };
 
 // Tests if the |ExternalEstimateProviderAndroid| notifies
 // |NetworkQualityEstimator|.
 TEST(ExternalEstimateProviderAndroidTest, DelegateTest) {
   content::TestBrowserThreadBundle thread_bundle(
       content::TestBrowserThreadBundle::IO_MAINLOOP);
 
   base::ShadowingAtExitManager at_exit_manager;
   base::HistogramTester histogram_tester;
   std::unique_ptr<TestExternalEstimateProviderAndroid>
       external_estimate_provider;
   external_estimate_provider.reset(new TestExternalEstimateProviderAndroid());
 
   TestExternalEstimateProviderAndroid* ptr = external_estimate_provider.get();
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator network_quality_estimator(
       std::move(external_estimate_provider), variation_params);
   ptr->NotifyUpdatedEstimateAvailable();
-  DCHECK(network_quality_estimator.IsNotified());
+  EXPECT_TRUE(network_quality_estimator.notified());
 
-  // EXTERNAL_ESTIMATE_PROVIDER_STATUS_NOT_AVAILABLE
-  histogram_tester.ExpectBucketCount("NQE.ExternalEstimateProviderStatus", 0,
-                                     0);
+  histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProviderStatus", 2);
 
   // EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE
   histogram_tester.ExpectBucketCount("NQE.ExternalEstimateProviderStatus", 1,
                                      1);
 
-  // EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED
-  // Updated once during NetworkQualityEstimator constructor and again,

[bengr, 2016/05/27 19:58:42]

Why is this no longer needed? (lines 94-118)

[tbansal1, 2016/05/27 23:39:14]

The previous logic was complicated. It was querying external estimate provider
(EEP), and then EEP was calling back NQE, and then NQE was calling EEP again to
get RTT and bandwidth estimate.

That logic is simplified now: NQE calls EEP, and EEP callbacks NQE, and in the
callback it provides all the different estimates. So, some of the enums that
were tracking this complicated stuff are no longer required.

-  // when |OnUpdatedEstimateAvailable| is called.
-  histogram_tester.ExpectBucketCount("NQE.ExternalEstimateProviderStatus", 2,
-                                     2);
-
-  // EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERY_SUCCESSFUL
-  // Updated once during NetworkQualityEstimator constructor and again,
-  // when |OnUpdatedEstimateAvailable| is called.
-  histogram_tester.ExpectBucketCount("NQE.ExternalEstimateProviderStatus", 3,
-                                     2);
-
   // EXTERNAL_ESTIMATE_PROVIDER_STATUS_CALLBACK
   histogram_tester.ExpectBucketCount("NQE.ExternalEstimateProviderStatus", 4,
                                      1);
-
-  histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProviderStatus", 6);
 }
 
 }  // namespace