Remove ScopedVector from prioritized_dispatcher_unittest

net/base/prioritized_dispatcher_unittest.cc

 // Copyright (c) 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.
 
 #include <ctype.h>
 #include <string>

[Deprecated (see juliatuttle), 2015/12/16 20:28:24]

This is no longer needed, since you're not storing a vector in the test fixture
at all.

+#include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/scoped_vector.h"
 #include "net/base/prioritized_dispatcher.h"
 #include "net/base/request_priority.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 // We rely on the priority enum values being sequential having starting at 0,
 // and increasing for higher priorities.
@@ skipping 110 matching lines @@
     bool running_;
 
     std::string* log_;
   };
 
  protected:
   void Prepare(const PrioritizedDispatcher::Limits& limits) {
     dispatcher_.reset(new PrioritizedDispatcher(limits));
   }
 
-  TestJob* AddJob(char data, Priority priority) {
-    TestJob* job = new TestJob(dispatcher_.get(), data, priority, &log_);
-    jobs_.push_back(job);
+  scoped_ptr<TestJob> AddJob(char data, Priority priority) {
+    scoped_ptr<TestJob> job(
+        make_scoped_ptr(new TestJob(dispatcher_.get(), data, priority, &log_)));

[Deprecated (see juliatuttle), 2015/12/16 20:28:24]

You don't need make_scoped_ptr here; scoped_ptr has a constructor that accepts
(and takes ownership of) a raw pointer.

     job->Add(false);
     return job;
   }
 
-  TestJob* AddJobAtHead(char data, Priority priority) {
-    TestJob* job = new TestJob(dispatcher_.get(), data, priority, &log_);
-    jobs_.push_back(job);
+  scoped_ptr<TestJob> AddJobAtHead(char data, Priority priority) {
+    scoped_ptr<TestJob> job(
+        make_scoped_ptr(new TestJob(dispatcher_.get(), data, priority, &log_)));

[Deprecated (see juliatuttle), 2015/12/16 20:28:24]

Ditto.

     job->Add(true);
     return job;
   }
 
   void Expect(const std::string& log) {
     EXPECT_EQ(0u, dispatcher_->num_queued_jobs());
     EXPECT_EQ(0u, dispatcher_->num_running_jobs());
     EXPECT_EQ(log, log_);
     log_.clear();
   }
 
   std::string log_;
   scoped_ptr<PrioritizedDispatcher> dispatcher_;
-  ScopedVector<TestJob> jobs_;
 };
 
 TEST_F(PrioritizedDispatcherTest, GetLimits) {
   // Set non-trivial initial limits.
   PrioritizedDispatcher::Limits original_limits(NUM_PRIORITIES, 5);
   original_limits.reserved_slots[HIGHEST] = 1;
   original_limits.reserved_slots[LOW] = 2;
   Prepare(original_limits);
 
   // Get current limits, make sure the original limits are returned.
@@ skipping 21 matching lines @@
     EXPECT_EQ(new_limits.reserved_slots[priority],
               retrieved_limits.reserved_slots[priority]);
   }
 }
 
 TEST_F(PrioritizedDispatcherTest, AddAFIFO) {
   // Allow only one running job.
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);
-  TestJob* job_b = AddJob('b', IDLE);
-  TestJob* job_c = AddJob('c', IDLE);
-  TestJob* job_d = AddJob('d', IDLE);
+  scoped_ptr<TestJob> job_a = AddJob('a', IDLE);
+  scoped_ptr<TestJob> job_b = AddJob('b', IDLE);
+  scoped_ptr<TestJob> job_c = AddJob('c', IDLE);
+  scoped_ptr<TestJob> job_d = AddJob('d', IDLE);
 
   ASSERT_TRUE(job_a->running());
   job_a->Finish();
   ASSERT_TRUE(job_b->running());
   job_b->Finish();
   ASSERT_TRUE(job_c->running());
   job_c->Finish();
   ASSERT_TRUE(job_d->running());
   job_d->Finish();
 
   Expect("a.b.c.d.");
 }
 
 TEST_F(PrioritizedDispatcherTest, AddPriority) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);
-  TestJob* job_b = AddJob('b', MEDIUM);
-  TestJob* job_c = AddJob('c', HIGHEST);
-  TestJob* job_d = AddJob('d', HIGHEST);
-  TestJob* job_e = AddJob('e', MEDIUM);
+  scoped_ptr<TestJob> job_a = AddJob('a', IDLE);
+  scoped_ptr<TestJob> job_b = AddJob('b', MEDIUM);
+  scoped_ptr<TestJob> job_c = AddJob('c', HIGHEST);
+  scoped_ptr<TestJob> job_d = AddJob('d', HIGHEST);
+  scoped_ptr<TestJob> job_e = AddJob('e', MEDIUM);
 
   ASSERT_TRUE(job_a->running());
   job_a->Finish();
   ASSERT_TRUE(job_c->running());
   job_c->Finish();
   ASSERT_TRUE(job_d->running());
   job_d->Finish();
   ASSERT_TRUE(job_b->running());
   job_b->Finish();
   ASSERT_TRUE(job_e->running());
   job_e->Finish();
 
   Expect("a.c.d.b.e.");
 }
 
 TEST_F(PrioritizedDispatcherTest, AddAtHead) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', MEDIUM);
-  TestJob* job_b = AddJobAtHead('b', MEDIUM);
-  TestJob* job_c = AddJobAtHead('c', HIGHEST);
-  TestJob* job_d = AddJobAtHead('d', HIGHEST);
-  TestJob* job_e = AddJobAtHead('e', MEDIUM);
-  TestJob* job_f = AddJob('f', MEDIUM);
+  scoped_ptr<TestJob> job_a = AddJob('a', MEDIUM);
+  scoped_ptr<TestJob> job_b = AddJobAtHead('b', MEDIUM);
+  scoped_ptr<TestJob> job_c = AddJobAtHead('c', HIGHEST);
+  scoped_ptr<TestJob> job_d = AddJobAtHead('d', HIGHEST);
+  scoped_ptr<TestJob> job_e = AddJobAtHead('e', MEDIUM);
+  scoped_ptr<TestJob> job_f = AddJob('f', MEDIUM);
 
   ASSERT_TRUE(job_a->running());
   job_a->Finish();
   ASSERT_TRUE(job_d->running());
   job_d->Finish();
   ASSERT_TRUE(job_c->running());
   job_c->Finish();
   ASSERT_TRUE(job_e->running());
   job_e->Finish();
   ASSERT_TRUE(job_b->running());
   job_b->Finish();
   ASSERT_TRUE(job_f->running());
   job_f->Finish();
 
   Expect("a.d.c.e.b.f.");
 }
 
 TEST_F(PrioritizedDispatcherTest, EnforceLimits) {
   // Reserve 2 for HIGHEST and 1 for LOW or higher.
   // This leaves 2 for LOWEST or lower.
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 5);
   limits.reserved_slots[HIGHEST] = 2;
   limits.reserved_slots[LOW] = 1;
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);    // Uses unreserved slot.
-  TestJob* job_b = AddJob('b', IDLE);    // Uses unreserved slot.
-  TestJob* job_c = AddJob('c', LOWEST);  // Must wait.
-  TestJob* job_d = AddJob('d', LOW);     // Uses reserved slot.
-  TestJob* job_e = AddJob('e', MEDIUM);  // Must wait.
-  TestJob* job_f = AddJob('f', HIGHEST); // Uses reserved slot.
-  TestJob* job_g = AddJob('g', HIGHEST); // Uses reserved slot.
-  TestJob* job_h = AddJob('h', HIGHEST); // Must wait.
+  scoped_ptr<TestJob> job_a = AddJob('a', IDLE);     // Uses unreserved slot.
+  scoped_ptr<TestJob> job_b = AddJob('b', IDLE);     // Uses unreserved slot.
+  scoped_ptr<TestJob> job_c = AddJob('c', LOWEST);   // Must wait.
+  scoped_ptr<TestJob> job_d = AddJob('d', LOW);      // Uses reserved slot.
+  scoped_ptr<TestJob> job_e = AddJob('e', MEDIUM);   // Must wait.
+  scoped_ptr<TestJob> job_f = AddJob('f', HIGHEST);  // Uses reserved slot.
+  scoped_ptr<TestJob> job_g = AddJob('g', HIGHEST);  // Uses reserved slot.
+  scoped_ptr<TestJob> job_h = AddJob('h', HIGHEST);  // Must wait.
 
   EXPECT_EQ(5u, dispatcher_->num_running_jobs());
   EXPECT_EQ(3u, dispatcher_->num_queued_jobs());
 
   ASSERT_TRUE(job_a->running());
   ASSERT_TRUE(job_b->running());
   ASSERT_TRUE(job_d->running());
   ASSERT_TRUE(job_f->running());
   ASSERT_TRUE(job_g->running());
   // a, b, d, f, g are running. Finish them in any order.
@@ skipping 12 matching lines @@
 
   Expect("abdfg.h...e..c..");
 }
 
 TEST_F(PrioritizedDispatcherTest, ChangePriority) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 2);
   // Reserve one slot only for HIGHEST priority requests.
   limits.reserved_slots[HIGHEST] = 1;
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);
-  TestJob* job_b = AddJob('b', LOW);
-  TestJob* job_c = AddJob('c', MEDIUM);
-  TestJob* job_d = AddJob('d', MEDIUM);
-  TestJob* job_e = AddJob('e', IDLE);
+  scoped_ptr<TestJob> job_a = AddJob('a', IDLE);
+  scoped_ptr<TestJob> job_b = AddJob('b', LOW);
+  scoped_ptr<TestJob> job_c = AddJob('c', MEDIUM);
+  scoped_ptr<TestJob> job_d = AddJob('d', MEDIUM);
+  scoped_ptr<TestJob> job_e = AddJob('e', IDLE);
 
   ASSERT_FALSE(job_b->running());
   ASSERT_FALSE(job_c->running());
   job_b->ChangePriority(MEDIUM);
   job_c->ChangePriority(LOW);
 
   ASSERT_TRUE(job_a->running());
   job_a->Finish();
   ASSERT_TRUE(job_d->running());
   job_d->Finish();
@@ skipping 10 matching lines @@
   ASSERT_TRUE(job_c->running());
   job_c->Finish();
 
   Expect("a.d.be..c.");
 }
 
 TEST_F(PrioritizedDispatcherTest, Cancel) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);
-  TestJob* job_b = AddJob('b', IDLE);
-  TestJob* job_c = AddJob('c', IDLE);
-  TestJob* job_d = AddJob('d', IDLE);
-  TestJob* job_e = AddJob('e', IDLE);
+  scoped_ptr<TestJob> job_a = AddJob('a', IDLE);
+  scoped_ptr<TestJob> job_b = AddJob('b', IDLE);
+  scoped_ptr<TestJob> job_c = AddJob('c', IDLE);
+  scoped_ptr<TestJob> job_d = AddJob('d', IDLE);
+  scoped_ptr<TestJob> job_e = AddJob('e', IDLE);
 
   ASSERT_FALSE(job_b->running());
   ASSERT_FALSE(job_d->running());
   job_b->Cancel();
   job_d->Cancel();
 
   ASSERT_TRUE(job_a->running());
   job_a->Finish();
   ASSERT_TRUE(job_c->running());
   job_c->Finish();
   ASSERT_TRUE(job_e->running());
   job_e->Finish();
 
   Expect("a.c.e.");
 }
 
 TEST_F(PrioritizedDispatcherTest, Evict) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);
-  TestJob* job_b = AddJob('b', LOW);
-  TestJob* job_c = AddJob('c', HIGHEST);
-  TestJob* job_d = AddJob('d', LOW);
-  TestJob* job_e = AddJob('e', HIGHEST);
+  scoped_ptr<TestJob> job_a = AddJob('a', IDLE);
+  scoped_ptr<TestJob> job_b = AddJob('b', LOW);
+  scoped_ptr<TestJob> job_c = AddJob('c', HIGHEST);
+  scoped_ptr<TestJob> job_d = AddJob('d', LOW);
+  scoped_ptr<TestJob> job_e = AddJob('e', HIGHEST);
 
-  EXPECT_EQ(job_b, dispatcher_->EvictOldestLowest());
-  EXPECT_EQ(job_d, dispatcher_->EvictOldestLowest());
+  EXPECT_EQ(job_b.get(), dispatcher_->EvictOldestLowest());
+  EXPECT_EQ(job_d.get(), dispatcher_->EvictOldestLowest());
 
   ASSERT_TRUE(job_a->running());
   job_a->Finish();
   ASSERT_TRUE(job_c->running());
   job_c->Finish();
   ASSERT_TRUE(job_e->running());
   job_e->Finish();
 
   Expect("a.c.e.");
 }
 
 TEST_F(PrioritizedDispatcherTest, EvictFromEmpty) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
   EXPECT_TRUE(dispatcher_->EvictOldestLowest() == NULL);
 }
 
 TEST_F(PrioritizedDispatcherTest, AddWhileZeroLimits) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 2);
   Prepare(limits);
 
   dispatcher_->SetLimitsToZero();
-  TestJob* job_a = AddJob('a', LOW);
-  TestJob* job_b = AddJob('b', MEDIUM);
-  TestJob* job_c = AddJobAtHead('c', MEDIUM);
+  scoped_ptr<TestJob> job_a = AddJob('a', LOW);
+  scoped_ptr<TestJob> job_b = AddJob('b', MEDIUM);
+  scoped_ptr<TestJob> job_c = AddJobAtHead('c', MEDIUM);
 
   EXPECT_EQ(0u, dispatcher_->num_running_jobs());
   EXPECT_EQ(3u, dispatcher_->num_queued_jobs());
 
   dispatcher_->SetLimits(limits);
   EXPECT_EQ(2u, dispatcher_->num_running_jobs());
   EXPECT_EQ(1u, dispatcher_->num_queued_jobs());
 
   ASSERT_TRUE(job_b->running());
   job_b->Finish();
 
   ASSERT_TRUE(job_c->running());
   job_c->Finish();
 
   ASSERT_TRUE(job_a->running());
   job_a->Finish();
 
   Expect("cb.a..");
 }
 
 TEST_F(PrioritizedDispatcherTest, ReduceLimitsWhileJobQueued) {
   PrioritizedDispatcher::Limits initial_limits(NUM_PRIORITIES, 2);
   Prepare(initial_limits);
 
-  TestJob* job_a = AddJob('a', MEDIUM);
-  TestJob* job_b = AddJob('b', MEDIUM);
-  TestJob* job_c = AddJob('c', MEDIUM);
-  TestJob* job_d = AddJob('d', MEDIUM);
-  TestJob* job_e = AddJob('e', MEDIUM);
+  scoped_ptr<TestJob> job_a = AddJob('a', MEDIUM);
+  scoped_ptr<TestJob> job_b = AddJob('b', MEDIUM);
+  scoped_ptr<TestJob> job_c = AddJob('c', MEDIUM);
+  scoped_ptr<TestJob> job_d = AddJob('d', MEDIUM);
+  scoped_ptr<TestJob> job_e = AddJob('e', MEDIUM);
 
   EXPECT_EQ(2u, dispatcher_->num_running_jobs());
   EXPECT_EQ(3u, dispatcher_->num_queued_jobs());
 
   // Reduce limits to just allow one job at a time.  Running jobs should not
   // be affected.
   dispatcher_->SetLimits(PrioritizedDispatcher::Limits(NUM_PRIORITIES, 1));
 
   EXPECT_EQ(2u, dispatcher_->num_running_jobs());
   EXPECT_EQ(3u, dispatcher_->num_queued_jobs());
@@ skipping 19 matching lines @@
   ASSERT_TRUE(job_e->running());
   job_e->Finish();
 
   Expect("ab..cd.e..");
 }
 
 TEST_F(PrioritizedDispatcherTest, ZeroLimitsThenCancel) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);
-  TestJob* job_b = AddJob('b', IDLE);
-  TestJob* job_c = AddJob('c', IDLE);
+  scoped_ptr<TestJob> job_a = AddJob('a', IDLE);
+  scoped_ptr<TestJob> job_b = AddJob('b', IDLE);
+  scoped_ptr<TestJob> job_c = AddJob('c', IDLE);
   dispatcher_->SetLimitsToZero();
 
   ASSERT_TRUE(job_a->running());
   EXPECT_FALSE(job_b->running());
   EXPECT_FALSE(job_c->running());
   job_a->Finish();
 
   EXPECT_FALSE(job_b->running());
   EXPECT_FALSE(job_c->running());
 
   // Cancelling b shouldn't start job c.
   job_b->Cancel();
   EXPECT_FALSE(job_c->running());
 
   // Restoring the limits should start c.
   dispatcher_->SetLimits(limits);
   ASSERT_TRUE(job_c->running());
   job_c->Finish();
 
   Expect("a.c.");
 }
 
 TEST_F(PrioritizedDispatcherTest, ZeroLimitsThenIncreasePriority) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 2);
   limits.reserved_slots[HIGHEST] = 1;
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);
-  TestJob* job_b = AddJob('b', IDLE);
+  scoped_ptr<TestJob> job_a = AddJob('a', IDLE);
+  scoped_ptr<TestJob> job_b = AddJob('b', IDLE);
   EXPECT_TRUE(job_a->running());
   EXPECT_FALSE(job_b->running());
   dispatcher_->SetLimitsToZero();
 
   job_b->ChangePriority(HIGHEST);
   EXPECT_FALSE(job_b->running());
   job_a->Finish();
   EXPECT_FALSE(job_b->running());
 
   job_b->Cancel();
   Expect("a.");
 }
 
 #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
 TEST_F(PrioritizedDispatcherTest, CancelNull) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
   EXPECT_DEBUG_DEATH(dispatcher_->Cancel(PrioritizedDispatcher::Handle()), "");
 }
 
 TEST_F(PrioritizedDispatcherTest, CancelMissing) {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
   Prepare(limits);
   AddJob('a', IDLE);
-  TestJob* job_b = AddJob('b', IDLE);
+  scoped_ptr<TestJob> job_b = AddJob('b', IDLE);
   PrioritizedDispatcher::Handle handle = job_b->handle();
   ASSERT_FALSE(handle.is_null());
   dispatcher_->Cancel(handle);
   EXPECT_DEBUG_DEATH(dispatcher_->Cancel(handle), "");
 }
 #endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
 
 }  // namespace
 
 }  // namespace net