Switch to standard integer types in media/.

media/blink/buffered_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 20 matching lines @@
 using blink::WebURLResponse;
 using blink::WebView;
 
 namespace media {
 
 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);
 };
 
 // Overrides CreateResourceLoader() to permit injecting a MockWebURLLoader.
 // Also keeps track of whether said MockWebURLLoader is actively loading.
 class MockBufferedDataSource : public BufferedDataSource {
  public:
   MockBufferedDataSource(
       const GURL& url,
       BufferedResourceLoader::CORSMode cors_mode,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       WebLocalFrame* frame,
       BufferedDataSourceHost* host)
       : BufferedDataSource(url,
                            cors_mode,
                            task_runner,
                            frame,
                            new media::MediaLog(),
                            host,
                            base::Bind(&MockBufferedDataSource::set_downloading,
                                       base::Unretained(this))),
         downloading_(false),
         loading_(false) {}
   virtual ~MockBufferedDataSource() {}
 
-  MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(int64, int64));
-  BufferedResourceLoader* CreateMockResourceLoader(int64 first_byte_position,
-                                                   int64 last_byte_position) {
+  MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(int64_t, int64_t));
+  BufferedResourceLoader* CreateMockResourceLoader(int64_t first_byte_position,
+                                                   int64_t last_byte_position) {
     CHECK(!loading_) << "Previous resource load wasn't cancelled";
 
     BufferedResourceLoader* loader =
         BufferedDataSource::CreateResourceLoader(first_byte_position,
                                                  last_byte_position);
 
     // Keep track of active loading state via loadAsynchronously() and cancel().
     NiceMock<MockWebURLLoader>* url_loader = new NiceMock<MockWebURLLoader>();
     ON_CALL(*url_loader, loadAsynchronously(_, _))
         .WillByDefault(Assign(&loading_, true));
@@ skipping 13 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(MockBufferedDataSource);
 };
 
-static const int64 kFileSize = 5000000;
-static const int64 kFarReadPosition = 4000000;
+static const int64_t kFileSize = 5000000;
+static const int64_t kFarReadPosition = 4000000;
 static const int kDataSize = 1024;
 
 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 BufferedDataSourceTest : public testing::Test {
  public:
   BufferedDataSourceTest()
@@ skipping 99 matching lines @@
   }
 
   void FinishLoading() {
     data_source_->set_loading(false);
     loader()->didFinishLoading(url_loader(), 0, -1);
     message_loop_.RunUntilIdle();
   }
 
   MOCK_METHOD1(ReadCallback, void(int size));
 
-  void ReadAt(int64 position) {
+  void ReadAt(int64_t position) {
     data_source_->Read(position, kDataSize, buffer_,
                        base::Bind(&BufferedDataSourceTest::ReadCallback,
                                   base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void ExecuteMixedResponseSuccessTest(const WebURLResponse& response1,
                                        const WebURLResponse& response2) {
     EXPECT_CALL(host_, SetTotalBytes(kFileSize));
     EXPECT_CALL(host_, AddBufferedByteRange(kDataSize, kDataSize * 2 - 1));
@@ skipping 62 matching lines @@
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
   StrictMock<MockBufferedDataSourceHost> host_;
   base::MessageLoop message_loop_;
   int bytes_received_;
 
  private:
   // Used for calling BufferedDataSource::Read().
-  uint8 buffer_[kDataSize];
+  uint8_t buffer_[kDataSize];
 
   BufferedDataSource::Preload preload_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest);
 };
 
 TEST_F(BufferedDataSourceTest, Range_Supported) {
   InitializeWith206Response();
 
   EXPECT_TRUE(data_source_->loading());
@@ skipping 371 matching lines @@
   InitializeWithFileResponse();
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_FALSE(data_source_->IsStreaming());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, StopDuringRead) {
   InitializeWith206Response();
 
-  uint8 buffer[256];
+  uint8_t buffer[256];
   data_source_->Read(0, arraysize(buffer), buffer, base::Bind(
       &BufferedDataSourceTest::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();
   }
   message_loop_.RunUntilIdle();
@@ skipping 304 matching lines @@
   // Read a bit from the beginning.
   ReadAt(0);
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
   ReceiveData(kDataSize);
 
   EXPECT_FALSE(active_loader());
 }
 
 }  // namespace media