Remove old Sleep and PostDelayedTask interfaces that use int ms instead of TimeDelta.

content/browser/download/byte_stream_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 "content/browser/download/byte_stream.h"
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 15 matching lines @@
 }
 
 namespace {
 
 class MockTaskRunner : public base::SequencedTaskRunner {
  public:
   MockTaskRunner();
 
   // TaskRunner functions.
   MOCK_METHOD3(PostDelayedTask, bool(const tracked_objects::Location&,
-                                     const base::Closure&, int64));
-  MOCK_METHOD3(PostDelayedTask, bool(const tracked_objects::Location&,
                                      const base::Closure&, base::TimeDelta));
 
   MOCK_METHOD3(PostNonNestableDelayedTask, bool(
       const tracked_objects::Location&,
       const base::Closure&,
-      int64 delay_ms));
-
-  MOCK_METHOD3(PostNonNestableDelayedTask, bool(
-      const tracked_objects::Location&,
-      const base::Closure&,
       base::TimeDelta));
 
   MOCK_CONST_METHOD0(RunsTasksOnCurrentThread, bool());
 
  protected:
   ~MockTaskRunner();
 };
 
 MockTaskRunner::MockTaskRunner() { }
 
@@ skipping 272 matching lines @@
   // to how much data is pushed onto the stream is not (currently) part
   // of the interface contract.  If it becomes part of the contract, the
   // tests below should get much more precise.
 
   // Confirm callback called when you add more than 33% of the buffer.
 
   // Setup callback
   int num_callbacks = 0;
   byte_stream_output->RegisterCallback(
       base::Bind(CountCallbacks, &num_callbacks));
-  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, 0))
+  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, base::TimeDelta()))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_callback),
                       Return(true)));
 
   EXPECT_TRUE(Write(byte_stream_input.get(), 4000));
   message_loop_.RunAllPending();
 
   // Check callback results match expectations.
   ::testing::Mock::VerifyAndClearExpectations(task_runner.get());
   EXPECT_CALL(*task_runner.get(), RunsTasksOnCurrentThread())
       .WillRepeatedly(Return(true));
@@ skipping 53 matching lines @@
   EXPECT_FALSE(Write(byte_stream_input.get(), 6000));
 
   // Allow bytes to transition (needed for message passing implementation),
   // and get and validate the data.
   message_loop_.RunAllPending();
   EXPECT_EQ(content::ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   // Setup expectations.
-  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, 0))
+  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, base::TimeDelta()))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_callback),
                       Return(true)));
 
   // Grab data, triggering callback.  Recorded on dispatch, but doesn't
   // happen because it's caught by the mock.
   EXPECT_EQ(content::ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   ::testing::Mock::VerifyAndClearExpectations(task_runner.get());
   EXPECT_CALL(*task_runner.get(), RunsTasksOnCurrentThread())
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   // Confirm that the callback passed to the mock does what we expect.
   EXPECT_EQ(0, num_callbacks);
   intermediate_callback.Run();
   EXPECT_EQ(1, num_callbacks);
 
   // Same drill with final buffer.
-  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, 0))
+  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, base::TimeDelta()))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_callback),
                       Return(true)));
   EXPECT_EQ(content::ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   ::testing::Mock::VerifyAndClearExpectations(task_runner.get());
   EXPECT_CALL(*task_runner.get(), RunsTasksOnCurrentThread())
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
   EXPECT_EQ(content::ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
@@ skipping 18 matching lines @@
       10000, &byte_stream_input, &byte_stream_output);
 
   scoped_refptr<net::IOBuffer> output_io_buffer;
   size_t output_length;
   base::Closure intermediate_callback;
 
   // Setup expectations and record initial state.
   int num_callbacks = 0;
   byte_stream_output->RegisterCallback(
       base::Bind(CountCallbacks, &num_callbacks));
-  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, 0))
+  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, base::TimeDelta()))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_callback),
                       Return(true)));
 
   // Add data, and pass it across.
   EXPECT_TRUE(Write(byte_stream_input.get(), 4000));
   message_loop_.RunAllPending();
 
   // The task runner should have been hit, but the callback count
   // isn't changed until we actually run the callback.
   ::testing::Mock::VerifyAndClearExpectations(task_runner.get());
@@ skipping 45 matching lines @@
   EXPECT_FALSE(Write(byte_stream_input.get(), 6000));
   message_loop_.RunAllPending();
 
   // Initial get should not trigger callback.
   EXPECT_EQ(content::ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
   message_loop_.RunAllPending();
 
   // Setup expectations.
-  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, 0))
+  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, base::TimeDelta()))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_callback),
                       Return(true)));
 
   // Second get *should* trigger callback.
   EXPECT_EQ(content::ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   ::testing::Mock::VerifyAndClearExpectations(task_runner.get());
   EXPECT_CALL(*task_runner.get(), RunsTasksOnCurrentThread())
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
 
   // Which should do the right thing when it's run.
   int num_alt_callbacks = 0;
   byte_stream_input->RegisterCallback(
       base::Bind(CountCallbacks, &num_alt_callbacks));
   intermediate_callback.Run();
   EXPECT_EQ(0, num_callbacks);
   EXPECT_EQ(1, num_alt_callbacks);
 
   // Third get should also trigger callback.
-  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, 0))
+  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, base::TimeDelta()))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_callback),
                       Return(true)));
   EXPECT_EQ(content::ByteStreamReader::STREAM_HAS_DATA,
             byte_stream_output->Read(&output_io_buffer, &output_length));
   ::testing::Mock::VerifyAndClearExpectations(task_runner.get());
   EXPECT_CALL(*task_runner.get(), RunsTasksOnCurrentThread())
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length));
   EXPECT_EQ(content::ByteStreamReader::STREAM_EMPTY,
             byte_stream_output->Read(&output_io_buffer, &output_length));
@@ skipping 11 matching lines @@
   content::CreateByteStream(
       message_loop_.message_loop_proxy(), task_runner,
       10000, &byte_stream_input, &byte_stream_output);
 
   base::Closure intermediate_callback;
 
   // Setup expectations and record initial state.
   int num_callbacks = 0;
   byte_stream_output->RegisterCallback(
       base::Bind(CountCallbacks, &num_callbacks));
-  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, 0))
+  EXPECT_CALL(*task_runner.get(), PostDelayedTask(_, _, base::TimeDelta()))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_callback),
                       Return(true)));
 
   // Immediately close the stream.
   byte_stream_input->Close(content::DOWNLOAD_INTERRUPT_REASON_NONE);
   ::testing::Mock::VerifyAndClearExpectations(task_runner.get());
   EXPECT_CALL(*task_runner.get(), RunsTasksOnCurrentThread())
       .WillRepeatedly(Return(true));
   intermediate_callback.Run();
   EXPECT_EQ(1, num_callbacks);
 }