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

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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 69 matching lines @@
                                                  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));
     ON_CALL(*url_loader, cancel())
         .WillByDefault(Assign(&loading_, false));
 
     // |test_loader_| will be used when Start() is called.
-    loader->test_loader_ = scoped_ptr<WebURLLoader>(url_loader);
+    loader->test_loader_ = std::unique_ptr<WebURLLoader>(url_loader);
     return loader;
   }
 
   bool loading() { return loading_; }
   void set_loading(bool loading) { loading_ = loading; }
   bool downloading() { return downloading_; }
   void set_downloading(bool downloading) { downloading_ = downloading; }
 
  private:
   // Whether the resource is downloading or deferred.
@@ skipping 102 matching lines @@
     message_loop_.RunUntilIdle();
     bytes_received_ = 0;
   }
 
   void Respond(const WebURLResponse& response) {
     loader()->didReceiveResponse(url_loader(), response);
     message_loop_.RunUntilIdle();
   }
 
   void ReceiveData(int size) {
-    scoped_ptr<char[]> data(new char[size]);
+    std::unique_ptr<char[]> data(new char[size]);
     memset(data.get(), 0xA5, size);  // Arbitrary non-zero value.
 
     loader()->didReceiveData(url_loader(), data.get(), size, size);
     message_loop_.RunUntilIdle();
     bytes_received_ += size;
     EXPECT_EQ(bytes_received_, data_source_->GetMemoryUsage());
   }
 
   void FinishLoading() {
     data_source_->set_loading(false);
@@ skipping 66 matching lines @@
   }
   int data_source_bitrate() { return data_source_->bitrate_; }
   double data_source_playback_rate() { return data_source_->playback_rate_; }
   int loader_bitrate() { return loader()->bitrate_; }
   double loader_playback_rate() { return loader()->playback_rate_; }
   bool is_local_source() { return data_source_->assume_fully_buffered(); }
   void set_might_be_reused_from_cache_in_future(bool value) {
     loader()->might_be_reused_from_cache_in_future_ = value;
   }
 
-  scoped_ptr<MockBufferedDataSource> data_source_;
+  std::unique_ptr<MockBufferedDataSource> data_source_;
 
-  scoped_ptr<TestResponseGenerator> response_generator_;
+  std::unique_ptr<TestResponseGenerator> response_generator_;
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
   StrictMock<MockBufferedDataSourceHost> host_;
   base::MessageLoop message_loop_;
   int bytes_received_;
 
  private:
   // Used for calling BufferedDataSource::Read().
@@ skipping 730 matching lines @@
   while (active_loader() && !active_loader()->deferred()) {
     ReceiveData(kDataSize);
     bytes_received += kDataSize;
   }
   EXPECT_GT(bytes_received, 0);
   EXPECT_LT(bytes_received + kDataSize, kFileSize);
   EXPECT_FALSE(active_loader());
 }
 
 }  // namespace media