Convert //media/blink from scoped_ptr to std::unique_ptr

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 <stdint.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 77 matching lines @@
     last_position_ = last_position;
 
     loader_.reset(new BufferedResourceLoader(
         gurl_, BufferedResourceLoader::kUnspecified,
         first_position_, last_position_,
         BufferedResourceLoader::kCapacityDefer, 0, 0,
         new MediaLog()));
 
     // |test_loader_| will be used when Start() is called.
     url_loader_ = new NiceMock<MockWebURLLoader>();
-    loader_->test_loader_ = scoped_ptr<blink::WebURLLoader>(url_loader_);
+    loader_->test_loader_ = std::unique_ptr<blink::WebURLLoader>(url_loader_);
   }
 
   void SetLoaderBuffer(int forward_capacity, int backward_capacity) {
     loader_->buffer_.set_forward_capacity(forward_capacity);
     loader_->buffer_.set_backward_capacity(backward_capacity);
     loader_->buffer_.Clear();
   }
 
   void Start() {
     InSequence s;
@@ skipping 109 matching lines @@
     EXPECT_CALL(*this, ProgressCallback(position + size - 1));
     loader_->didReceiveData(url_loader_,
                             reinterpret_cast<char*>(data_ + position),
                             size,
                             size);
   }
 
   void WriteData(int size) {
     EXPECT_CALL(*this, ProgressCallback(_));
 
-    scoped_ptr<char[]> data(new char[size]);
+    std::unique_ptr<char[]> data(new char[size]);
     loader_->didReceiveData(url_loader_, data.get(), size, size);
   }
 
   void WriteUntilThreshold() {
     int buffered = loader_->buffer_.forward_bytes();
     int capacity = loader_->buffer_.forward_capacity();
     CHECK_LT(buffered, capacity);
 
     EXPECT_CALL(*this, LoadingCallback(
         BufferedResourceLoader::kLoadingDeferred));
@@ skipping 58 matching lines @@
   MOCK_METHOD1(StartCallback, void(BufferedResourceLoader::Status));
   MOCK_METHOD2(ReadCallback, void(BufferedResourceLoader::Status, int));
   MOCK_METHOD1(LoadingCallback, void(BufferedResourceLoader::LoadingState));
   MOCK_METHOD1(ProgressCallback, void(int64_t));
 
  protected:
   GURL gurl_;
   int64_t first_position_;
   int64_t last_position_;
 
-  scoped_ptr<BufferedResourceLoader> loader_;
+  std::unique_ptr<BufferedResourceLoader> loader_;
   NiceMock<MockWebURLLoader>* url_loader_;
 
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
   base::MessageLoop message_loop_;
 
   uint8_t data_[kDataSize];
 
@@ skipping 845 matching lines @@
 
   // 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