Domain Reliability: More security review.

components/domain_reliability/scheduler_unittest.cc

 // Copyright 2014 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 "components/domain_reliability/scheduler.h"
 
 #include "base/bind.h"
 #include "base/time/time.h"
+#include "components/domain_reliability/config.h"
 #include "components/domain_reliability/test_util.h"
 #include "components/domain_reliability/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace domain_reliability {
 
 class DomainReliabilitySchedulerTest : public testing::Test {
  public:
-  DomainReliabilitySchedulerTest() :
-      num_collectors_(0),
-      params_(CreateDefaultParams()),
-      callback_called_(false) {
-  }
+  DomainReliabilitySchedulerTest()
+      : num_collectors_(0),
+        params_(CreateDefaultParams()),
+        callback_called_(false) {}
 
   void CreateScheduler(int num_collectors) {
     DCHECK_LT(0, num_collectors);
     DCHECK(!scheduler_);
 
     num_collectors_ = num_collectors;
     scheduler_.reset(new DomainReliabilityScheduler(
         &time_,
         num_collectors_,
         params_,
@@ skipping 38 matching lines @@
              << "got upload between " << callback_min_.InSeconds()
              << " and " << callback_max_.InSeconds() << " seconds from now";
     } else {
       return ::testing::AssertionFailure()
              << "expected upload between " << expected_min.InSeconds()
              << " and " << expected_max.InSeconds() << " seconds from now, "
              << "got no upload";
     }
   }
 
-  ::testing::AssertionResult CheckStartingUpload(int expected_collector) {
+  ::testing::AssertionResult CheckStartingUpload(size_t expected_collector) {
     DCHECK(scheduler_);
-    DCHECK_LE(0, expected_collector);
     DCHECK_GT(num_collectors_, expected_collector);
 
-    int collector;
-    scheduler_->OnUploadStart(&collector);
+    size_t collector = scheduler_->OnUploadStart();
     if (collector == expected_collector)
       return ::testing::AssertionSuccess();
 
     return ::testing::AssertionFailure()
            << "expected upload to collector " << expected_collector
            << ", got upload to collector " << collector;
   }
 
   TimeDelta min_delay() const { return params_.minimum_upload_delay; }
   TimeDelta max_delay() const { return params_.maximum_upload_delay; }
   TimeDelta retry_interval() const { return params_.upload_retry_interval; }
   TimeDelta zero_delta() const { return base::TimeDelta::FromMicroseconds(0); }
 
  protected:
   void ScheduleUploadCallback(TimeDelta min, TimeDelta max) {
     callback_called_ = true;
     callback_min_ = min;
     callback_max_ = max;
   }
 
   MockTime time_;
-  int num_collectors_;
+  size_t num_collectors_;
   DomainReliabilityScheduler::Params params_;
   scoped_ptr<DomainReliabilityScheduler> scheduler_;
 
   bool callback_called_;
   TimeDelta callback_min_;
   TimeDelta callback_max_;
 };
 
 TEST_F(DomainReliabilitySchedulerTest, Create) {
   CreateScheduler(1);
@@ skipping 84 matching lines @@
 
   ASSERT_TRUE(CheckPendingUpload(zero_delta(), max_delay() - min_delay()));
   time_.Advance(retry_interval());
 
   // T = min_delay + retry_interval; collector 0 should be active again.
   ASSERT_TRUE(CheckStartingUpload(0));
   scheduler_->OnUploadComplete(true);
 }
 
 }  // namespace domain_reliability