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

media/blink/resource_multibuffer_data_provider_unittest.cc

 // Copyright 2015 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 "media/blink/resource_multibuffer_data_provider.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 74 matching lines @@
     gurl_ = GURL(url);
     url_data_ = url_index_->GetByUrl(gurl_, UrlData::CORS_UNSPECIFIED);
     DCHECK(url_data_);
     DCHECK(url_data_->frame());
     url_data_->OnRedirect(
         base::Bind(&ResourceMultiBufferDataProviderTest::RedirectCallback,
                    base::Unretained(this)));
 
     first_position_ = first_position;
 
-    scoped_ptr<ResourceMultiBufferDataProvider> loader(
+    std::unique_ptr<ResourceMultiBufferDataProvider> loader(
         new ResourceMultiBufferDataProvider(url_data_.get(), first_position_));
     loader_ = loader.get();
     url_data_->multibuffer()->AddProvider(std::move(loader));
 
     // |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 Start() {
     InSequence s;
     EXPECT_CALL(*url_loader_,
                 loadAsynchronously(Truly(CorrectAcceptEncoding), loader_));
 
     loader_->Start();
   }
 
@@ skipping 78 matching lines @@
     url_data_ = nullptr;
   }
 
   // Helper method to write to |loader_| from |data_|.
   void WriteLoader(int position, int size) {
     loader_->didReceiveData(
         url_loader_, reinterpret_cast<char*>(data_ + position), size, size);
   }
 
   void WriteData(int size) {
-    scoped_ptr<char[]> data(new char[size]);
+    std::unique_ptr<char[]> data(new char[size]);
     loader_->didReceiveData(url_loader_, data.get(), size, size);
   }
 
   // Verifies that data in buffer[0...size] is equal to data_[pos...pos+size].
   void VerifyBuffer(uint8_t* buffer, int pos, int size) {
     EXPECT_EQ(0, memcmp(buffer, data_ + pos, size));
   }
 
   bool HasActiveLoader() { return loader_->active_loader_ != nullptr; }
   MOCK_METHOD1(RedirectCallback, void(const scoped_refptr<UrlData>&));
 
   void SetUrlData(const scoped_refptr<UrlData>& new_url_data) {
     url_data_ = new_url_data;
   }
 
  protected:
   GURL gurl_;
   int64_t first_position_;
 
-  scoped_ptr<UrlIndex> url_index_;
+  std::unique_ptr<UrlIndex> url_index_;
   scoped_refptr<UrlData> url_data_;
   scoped_refptr<UrlData> redirected_to_;
   // The loader is owned by the UrlData above.
   ResourceMultiBufferDataProvider* loader_;
   NiceMock<MockWebURLLoader>* url_loader_;
 
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
@@ skipping 93 matching lines @@
 TEST_F(ResourceMultiBufferDataProviderTest, TestRedirects) {
   // Test redirect.
   Initialize(kHttpUrl, 0);
   Start();
   Redirect(kHttpRedirect);
   FullResponse(1024);
   StopWhenLoad();
 }
 
 }  // namespace media