Switch to standard integer types in media/.

media/blink/multibuffer_data_source_unittest.cc

 // Copyright 2013 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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
@@ skipping 144 matching lines @@
 
  private:
   scoped_refptr<TestUrlData> last_url_data_;
 };
 
 class MockBufferedDataSourceHost : public BufferedDataSourceHost {
  public:
   MockBufferedDataSourceHost() {}
   virtual ~MockBufferedDataSourceHost() {}
 
-  MOCK_METHOD1(SetTotalBytes, void(int64 total_bytes));
-  MOCK_METHOD2(AddBufferedByteRange, void(int64 start, int64 end));
+  MOCK_METHOD1(SetTotalBytes, void(int64_t total_bytes));
+  MOCK_METHOD2(AddBufferedByteRange, void(int64_t start, int64_t end));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSourceHost);
 };
 
 class MockMultibufferDataSource : public MultibufferDataSource {
  public:
   MockMultibufferDataSource(
       const GURL& url,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
@@ skipping 19 matching lines @@
  private:
   // Whether the resource is downloading or deferred.
   bool downloading_;
 
   // Whether the resource load has starting loading but yet to been cancelled.
   bool loading_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMultibufferDataSource);
 };
 
-static const int64 kFileSize = 5000000;
-static const int64 kFarReadPosition = 3997696;
+static const int64_t kFileSize = 5000000;
+static const int64_t kFarReadPosition = 3997696;
 static const int kDataSize = 32 << 10;
 
 static const char kHttpUrl[] = "http://localhost/foo.webm";
 static const char kFileUrl[] = "file:///tmp/bar.webm";
 static const char kHttpDifferentPathUrl[] = "http://localhost/bar.webm";
 static const char kHttpDifferentOriginUrl[] = "http://127.0.0.1/foo.webm";
 
 class MultibufferDataSourceTest : public testing::Test {
  public:
   MultibufferDataSourceTest()
@@ skipping 106 matching lines @@
   void Restart() {
     EXPECT_TRUE(data_provider());
     EXPECT_FALSE(active_loader_allownull());
     if (!data_provider())
       return;
     data_provider()->Start();
   }
 
   MOCK_METHOD1(ReadCallback, void(int size));
 
-  void ReadAt(int64 position, int64 howmuch = kDataSize) {
+  void ReadAt(int64_t position, int64_t howmuch = kDataSize) {
     data_source_->Read(position, howmuch, buffer_,
                        base::Bind(&MultibufferDataSourceTest::ReadCallback,
                                   base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void ExecuteMixedResponseSuccessTest(const WebURLResponse& response1,
                                        const WebURLResponse& response2) {
     EXPECT_CALL(host_, SetTotalBytes(kFileSize));
     EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
@@ skipping 77 matching lines @@
       return nullptr;
     return active_loader()->loader_.get();
   }
 
   bool loading() { return multibuffer()->loading(); }
 
   MultibufferDataSource::Preload preload() { return data_source_->preload_; }
   void set_preload(MultibufferDataSource::Preload preload) {
     preload_ = preload;
   }
-  int64 preload_high() {
+  int64_t preload_high() {
     CHECK(loader());
     return loader()->preload_high();
   }
-  int64 preload_low() {
+  int64_t preload_low() {
     CHECK(loader());
     return loader()->preload_low();
   }
   int data_source_bitrate() { return data_source_->bitrate_; }
   double data_source_playback_rate() { return data_source_->playback_rate_; }
   bool is_local_source() { return data_source_->assume_fully_buffered(); }
   void set_might_be_reused_from_cache_in_future(bool value) {
     data_source_->url_data_->set_cacheable(value);
   }
 
  protected:
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
   MultibufferDataSource::Preload preload_;
   linked_ptr<TestUrlIndex> url_index_;
 
   scoped_ptr<MockMultibufferDataSource> data_source_;
 
   scoped_ptr<TestResponseGenerator> response_generator_;
 
   StrictMock<MockBufferedDataSourceHost> host_;
   base::MessageLoop message_loop_;
 
   // Used for calling MultibufferDataSource::Read().
-  uint8 buffer_[kDataSize * 2];
+  uint8_t buffer_[kDataSize * 2];
 
   DISALLOW_COPY_AND_ASSIGN(MultibufferDataSourceTest);
 };
 
 TEST_F(MultibufferDataSourceTest, Range_Supported) {
   InitializeWith206Response();
 
   EXPECT_TRUE(loading());
   EXPECT_FALSE(data_source_->IsStreaming());
   Stop();
@@ skipping 383 matching lines @@
   InitializeWithFileResponse();
 
   EXPECT_TRUE(loading());
   EXPECT_FALSE(data_source_->IsStreaming());
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, StopDuringRead) {
   InitializeWith206Response();
 
-  uint8 buffer[256];
+  uint8_t buffer[256];
   data_source_->Read(0, arraysize(buffer), buffer,
                      base::Bind(&MultibufferDataSourceTest::ReadCallback,
                                 base::Unretained(this)));
 
   // The outstanding read should fail before the stop callback runs.
   {
     InSequence s;
     EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
     data_source_->Stop();
   }
@@ skipping 331 matching lines @@
   ASSERT_TRUE(active_loader());
 
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
   ReceiveData(kDataSize);
 
   EXPECT_FALSE(active_loader_allownull());
 }
 
 }  // namespace media