Switch to standard integer types in media/.

media/blink/buffered_resource_loader_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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 99 matching lines @@
     loader_->Start(
         base::Bind(&BufferedResourceLoaderTest::StartCallback,
                    base::Unretained(this)),
         base::Bind(&BufferedResourceLoaderTest::LoadingCallback,
                    base::Unretained(this)),
         base::Bind(&BufferedResourceLoaderTest::ProgressCallback,
                    base::Unretained(this)),
         view_->mainFrame());
   }
 
-  void FullResponse(int64 instance_size) {
+  void FullResponse(int64_t instance_size) {
     FullResponse(instance_size, BufferedResourceLoader::kOk);
   }
 
-  void FullResponse(int64 instance_size,
+  void FullResponse(int64_t instance_size,
                     BufferedResourceLoader::Status status) {
     EXPECT_CALL(*this, StartCallback(status));
 
     WebURLResponse response(gurl_);
     response.setHTTPHeaderField(WebString::fromUTF8("Content-Length"),
                                 WebString::fromUTF8(base::StringPrintf("%"
                                     PRId64, instance_size)));
     response.setExpectedContentLength(instance_size);
     response.setHTTPStatusCode(kHttpOK);
     loader_->didReceiveResponse(url_loader_, response);
 
     if (status == BufferedResourceLoader::kOk) {
       EXPECT_EQ(instance_size, loader_->content_length());
       EXPECT_EQ(instance_size, loader_->instance_size());
     }
 
     EXPECT_FALSE(loader_->range_supported());
   }
 
-  void PartialResponse(int64 first_position, int64 last_position,
-                       int64 instance_size) {
+  void PartialResponse(int64_t first_position,
+                       int64_t last_position,
+                       int64_t instance_size) {
     PartialResponse(first_position, last_position, instance_size, false, true);
   }
 
-  void PartialResponse(int64 first_position, int64 last_position,
-                       int64 instance_size, bool chunked, bool accept_ranges) {
+  void PartialResponse(int64_t first_position,
+                       int64_t last_position,
+                       int64_t instance_size,
+                       bool chunked,
+                       bool accept_ranges) {
     EXPECT_CALL(*this, StartCallback(BufferedResourceLoader::kOk));
 
     WebURLResponse response(gurl_);
     response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"),
                                 WebString::fromUTF8(base::StringPrintf("bytes "
                                             "%" PRId64 "-%" PRId64 "/%" PRId64,
                                             first_position,
                                             last_position,
                                             instance_size)));
 
     // HTTP 1.1 doesn't permit Content-Length with Transfer-Encoding: chunked.
-    int64 content_length = -1;
+    int64_t content_length = -1;
     if (chunked) {
       response.setHTTPHeaderField(WebString::fromUTF8("Transfer-Encoding"),
                                   WebString::fromUTF8("chunked"));
     } else {
       content_length = last_position - first_position + 1;
     }
     response.setExpectedContentLength(content_length);
 
     // A server isn't required to return Accept-Ranges even though it might.
     if (accept_ranges) {
@@ skipping 53 matching lines @@
     int buffered = loader_->buffer_.forward_bytes();
     int capacity = loader_->buffer_.forward_capacity();
     CHECK_LT(buffered, capacity);
 
     EXPECT_CALL(*this, LoadingCallback(
         BufferedResourceLoader::kLoadingDeferred));
     WriteData(capacity - buffered);
   }
 
   // Helper method to read from |loader_|.
-  void ReadLoader(int64 position, int size, uint8* buffer) {
+  void ReadLoader(int64_t position, int size, uint8_t* buffer) {
     loader_->Read(position, size, buffer,
                   base::Bind(&BufferedResourceLoaderTest::ReadCallback,
                              base::Unretained(this)));
   }
 
   // Verifies that data in buffer[0...size] is equal to data_[pos...pos+size].
-  void VerifyBuffer(uint8* buffer, int pos, int size) {
+  void VerifyBuffer(uint8_t* buffer, int pos, int size) {
     EXPECT_EQ(0, memcmp(buffer, data_ + pos, size));
   }
 
-  void ConfirmLoaderOffsets(int64 expected_offset,
+  void ConfirmLoaderOffsets(int64_t expected_offset,
                             int expected_first_offset,
                             int expected_last_offset) {
     EXPECT_EQ(loader_->offset_, expected_offset);
     EXPECT_EQ(loader_->first_offset_, expected_first_offset);
     EXPECT_EQ(loader_->last_offset_, expected_last_offset);
   }
 
   void ConfirmBufferState(int backward_bytes,
                           int backward_capacity,
                           int forward_bytes,
@@ skipping 25 matching lines @@
     static const int kMaxBufferCapacity = 20 * 1024 * 1024;
     EXPECT_LE(loader_->buffer_.forward_capacity(), kMaxBufferCapacity);
     EXPECT_LE(loader_->buffer_.backward_capacity(), kMaxBufferCapacity);
   }
 
   bool HasActiveLoader() { return loader_->active_loader_; }
 
   MOCK_METHOD1(StartCallback, void(BufferedResourceLoader::Status));
   MOCK_METHOD2(ReadCallback, void(BufferedResourceLoader::Status, int));
   MOCK_METHOD1(LoadingCallback, void(BufferedResourceLoader::LoadingState));
-  MOCK_METHOD1(ProgressCallback, void(int64));
+  MOCK_METHOD1(ProgressCallback, void(int64_t));
 
  protected:
   GURL gurl_;
-  int64 first_position_;
-  int64 last_position_;
+  int64_t first_position_;
+  int64_t last_position_;
 
   scoped_ptr<BufferedResourceLoader> loader_;
   NiceMock<MockWebURLLoader>* url_loader_;
 
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
   base::MessageLoop message_loop_;
 
-  uint8 data_[kDataSize];
+  uint8_t data_[kDataSize];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoaderTest);
 };
 
 TEST_F(BufferedResourceLoaderTest, StartStop) {
   Initialize(kHttpUrl, -1, -1);
   Start();
   StopWhenLoad();
 }
@@ skipping 74 matching lines @@
   StopWhenLoad();
 }
 
 // Tests the logic of sliding window for data buffering and reading.
 TEST_F(BufferedResourceLoaderTest, BufferAndRead) {
   Initialize(kHttpUrl, 10, 29);
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
   Start();
   PartialResponse(10, 29, 30);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
   InSequence s;
 
   // Writes 10 bytes and read them back.
   WriteLoader(10, 10);
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   ReadLoader(10, 10, buffer);
   VerifyBuffer(buffer, 10, 10);
 
   // Writes 10 bytes and read 2 times.
   WriteLoader(20, 10);
@@ skipping 31 matching lines @@
   ReadLoader(30, 10, buffer);
 }
 
 // Tests the logic of expanding the data buffer for large reads.
 TEST_F(BufferedResourceLoaderTest, ReadExtendBuffer) {
   Initialize(kHttpUrl, 10, 0x014FFFFFF);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 0x014FFFFFF, 0x015000000);
 
-  uint8 buffer[20];
+  uint8_t buffer[20];
   InSequence s;
 
   // Write more than forward capacity and read it back. Ensure forward capacity
   // gets reset after reading.
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   WriteLoader(10, 20);
 
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 20));
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(10, 20, buffer);
@@ skipping 28 matching lines @@
   ConfirmLoaderBufferForwardCapacity(10);
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, ReadOutsideBuffer) {
   Initialize(kHttpUrl, 10, 0x00FFFFFF);
   Start();
   PartialResponse(10, 0x00FFFFFF, 0x01000000);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
   InSequence s;
 
   // Read very far ahead will get a cache miss.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
   ReadLoader(0x00FFFFFF, 1, buffer);
 
   // The following call will not call ReadCallback() because it is waiting for
   // data to arrive.
   ReadLoader(10, 10, buffer);
 
   // Writing to loader will fulfill the read request.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   WriteLoader(10, 20);
   VerifyBuffer(buffer, 10, 10);
 
   // The following call cannot be fulfilled now.
   ReadLoader(25, 10, buffer);
 
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5));
   loader_->didFinishLoading(url_loader_, 0, -1);
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
   InSequence s;
 
   // We should convert any error we receive to BufferedResourceLoader::kFailed.
   ReadLoader(10, 10, buffer);
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
   WebURLError error;
   error.reason = net::ERR_TIMED_OUT;
   error.isCancellation = false;
   loader_->didFail(url_loader_, error);
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestFailedWithNoPendingReads) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
   InSequence s;
 
   // Write enough data so that a read would technically complete had the request
   // not failed.
   WriteLoader(10, 20);
 
   // Fail without a pending read.
   WebURLError error;
   error.reason = net::ERR_TIMED_OUT;
   error.isCancellation = false;
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
   loader_->didFail(url_loader_, error);
 
   // Now we should immediately fail any read even if we have data buffered.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
   ReadLoader(10, 10, buffer);
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestCancelledWhenRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
   InSequence s;
 
   // We should convert any error we receive to BufferedResourceLoader::kFailed.
   ReadLoader(10, 10, buffer);
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
   WebURLError error;
   error.reason = 0;
   error.isCancellation = true;
   loader_->didFail(url_loader_, error);
 }
 
 // Tests the data buffering logic of NeverDefer strategy.
 TEST_F(BufferedResourceLoaderTest, NeverDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
 
   // Read past the buffer size; should not defer regardless.
   WriteLoader(10, 10);
   WriteLoader(20, 50);
 
   // Should move past window.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
   ReadLoader(10, 10, buffer);
 
   StopWhenLoad();
 }
 
 // Tests the data buffering logic of ReadThenDefer strategy.
 TEST_F(BufferedResourceLoaderTest, ReadThenDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kReadThenDefer);
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
 
   // Make an outstanding read request.
   ReadLoader(10, 10, buffer);
 
   // Receive almost enough data to cover, shouldn't defer.
   WriteLoader(10, 9);
 
   // As soon as we have received enough data to fulfill the read, defer.
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
@@ skipping 28 matching lines @@
   StopWhenLoad();
 }
 
 // Tests the data buffering logic of kCapacityDefer strategy.
 TEST_F(BufferedResourceLoaderTest, ThresholdDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
   InSequence s;
 
   // Write half of capacity: keep not deferring.
   WriteData(5);
 
   // Write rest of space until capacity: start deferring.
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   WriteData(5);
 
   // Read a byte from the buffer: stop deferring.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(10, 1, buffer);
 
   // Write a byte to hit capacity: start deferring.
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   WriteData(6);
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_ReadForwardsPastBuffered) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[256];
+  uint8_t buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(10, 1, buffer);
   ConfirmBufferState(1, 10, 9, 10);
   ConfirmLoaderOffsets(11, 0, 0);
 
@@ skipping 24 matching lines @@
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_ReadBackwardsPastBuffered) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[256];
+  uint8_t buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
 
   // *** TRICKY BUSINESS, PT. II ***
   // Read backwards a little too much: cache miss.
   //
@@ skipping 12 matching lines @@
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_SmallReadWithinThreshold) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[256];
+  uint8_t buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
 
   // *** TRICKY BUSINESS, PT. III ***
   // Read past forward capacity but within capacity: stop deferring.
   //
@@ skipping 27 matching lines @@
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadWithinThreshold) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[256];
+  uint8_t buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
 
   // *** TRICKY BUSINESS, PT. IV ***
   // Read a large amount past forward capacity but within
   // capacity: stop deferring.
@@ skipping 34 matching lines @@
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadBackwards) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[256];
+  uint8_t buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(10, 10, buffer);
   WriteUntilThreshold();
   ConfirmBufferState(10, 10, 10, 10);
   ConfirmLoaderOffsets(20, 0, 0);
@@ skipping 40 matching lines @@
 
 TEST_F(BufferedResourceLoaderTest, Tricky_ReadPastThreshold) {
   const int kSize = 5 * 1024 * 1024;
   const int kThreshold = 2 * 1024 * 1024;
 
   Initialize(kHttpUrl, 10, kSize);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, kSize - 1, kSize);
 
-  uint8 buffer[256];
+  uint8_t buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
 
   // *** TRICKY BUSINESS, PT. VI ***
   // Read past the forward wait threshold: cache miss.
   //
@@ skipping 137 matching lines @@
 }
 
 TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_AboveUpperBound) {
   Initialize(kHttpUrl, -1, -1);
   Start();
   loader_->SetPlaybackRate(100);
   CheckBufferWindowBounds();
   StopWhenLoad();
 }
 
-static void ExpectContentRange(
-    const std::string& str, bool expect_success,
-    int64 expected_first, int64 expected_last, int64 expected_size) {
-  int64 first, last, size;
+static void ExpectContentRange(const std::string& str,
+                               bool expect_success,
+                               int64_t expected_first,
+                               int64_t expected_last,
+                               int64_t expected_size) {
+  int64_t first, last, size;
   ASSERT_EQ(expect_success, BufferedResourceLoader::ParseContentRange(
       str, &first, &last, &size)) << str;
   if (!expect_success)
     return;
   EXPECT_EQ(first, expected_first);
   EXPECT_EQ(last, expected_last);
   EXPECT_EQ(size, expected_size);
 }
 
 static void ExpectContentRangeFailure(const std::string& str) {
   ExpectContentRange(str, false, 0, 0, 0);
 }
 
-static void ExpectContentRangeSuccess(
-    const std::string& str,
-    int64 expected_first, int64 expected_last, int64 expected_size) {
+static void ExpectContentRangeSuccess(const std::string& str,
+                                      int64_t expected_first,
+                                      int64_t expected_last,
+                                      int64_t expected_size) {
   ExpectContentRange(str, true, expected_first, expected_last, expected_size);
 }
 
 TEST(BufferedResourceLoaderStandaloneTest, ParseContentRange) {
   ExpectContentRangeFailure("cytes 0-499/500");
   ExpectContentRangeFailure("bytes 0499/500");
   ExpectContentRangeFailure("bytes 0-499500");
   ExpectContentRangeFailure("bytes 0-499/500-blorg");
   ExpectContentRangeFailure("bytes 0-499/500-1");
   ExpectContentRangeFailure("bytes 0-499/400");
@@ skipping 10 matching lines @@
 
 // Tests the data buffering logic of ReadThenDefer strategy.
 TEST_F(BufferedResourceLoaderTest, CancelAfterDeferral) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kReadThenDefer);
   loader_->CancelUponDeferral();
   Start();
   PartialResponse(10, 99, 100);
 
-  uint8 buffer[10];
+  uint8_t buffer[10];
 
   // Make an outstanding read request.
   ReadLoader(10, 10, buffer);
 
   // Receive almost enough data to cover, shouldn't defer.
   WriteLoader(10, 9);
   EXPECT_TRUE(HasActiveLoader());
 
   // As soon as we have received enough data to fulfill the read, defer.
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   WriteLoader(19, 1);
   VerifyBuffer(buffer, 10, 10);
   EXPECT_FALSE(HasActiveLoader());
 }
 
 }  // namespace media