Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/gaia/gaia_oauth_client_unittest.cc

 // Copyright (c) 2012 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.
 //
 // A complete set of unit tests for GaiaOAuthClient.
 
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
@@ skipping 71 matching lines @@
 
 class MockOAuthFetcherFactory : public net::URLFetcherFactory,
                                 public net::ScopedURLFetcherFactory {
  public:
   MockOAuthFetcherFactory()
       : net::ScopedURLFetcherFactory(this),
         response_code_(net::HTTP_OK),
         complete_immediately_(true) {
   }
   ~MockOAuthFetcherFactory() override {}
-  scoped_ptr<net::URLFetcher> CreateURLFetcher(
+  std::unique_ptr<net::URLFetcher> CreateURLFetcher(
       int id,
       const GURL& url,
       net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* d) override {
     url_fetcher_ = new MockOAuthFetcher(
         response_code_,
         max_failure_count_,
         complete_immediately_,
         url,
         results_,
         request_type,
         d);
-    return scoped_ptr<net::URLFetcher>(url_fetcher_);
+    return std::unique_ptr<net::URLFetcher>(url_fetcher_);
   }
   void set_response_code(int response_code) {
     response_code_ = response_code;
   }
   void set_max_failure_count(int count) {
     max_failure_count_ = count;
   }
   void set_results(const std::string& results) {
     results_ = results;
   }
@@ skipping 98 matching lines @@
   MOCK_METHOD0(OnOAuthError, void());
   MOCK_METHOD1(OnNetworkError, void(int response_code));
 
   // gMock doesn't like methods that take or return scoped_ptr.  A
   // work-around is to create a mock method that takes a raw ptr, and
   // override the problematic method to call through to it.
   // https://groups.google.com/a/chromium.org/d/msg/chromium-dev/01sDxsJ1OYw/I_S0xCBRF2oJ
   MOCK_METHOD1(OnGetUserInfoResponsePtr,
                void(const base::DictionaryValue* user_info));
   void OnGetUserInfoResponse(
-      scoped_ptr<base::DictionaryValue> user_info) override {
+      std::unique_ptr<base::DictionaryValue> user_info) override {
     user_info_.reset(user_info.release());
     OnGetUserInfoResponsePtr(user_info_.get());
   }
   MOCK_METHOD1(OnGetTokenInfoResponsePtr,
                void(const base::DictionaryValue* token_info));
   void OnGetTokenInfoResponse(
-      scoped_ptr<base::DictionaryValue> token_info) override {
+      std::unique_ptr<base::DictionaryValue> token_info) override {
     token_info_.reset(token_info.release());
     OnGetTokenInfoResponsePtr(token_info_.get());
   }
 
  private:
-  scoped_ptr<base::DictionaryValue> user_info_;
-  scoped_ptr<base::DictionaryValue> token_info_;
+  std::unique_ptr<base::DictionaryValue> user_info_;
+  std::unique_ptr<base::DictionaryValue> token_info_;
   DISALLOW_COPY_AND_ASSIGN(MockGaiaOAuthClientDelegate);
 };
 
 TEST_F(GaiaOAuthClientTest, NetworkFailure) {
   int response_code = net::HTTP_INTERNAL_SERVER_ERROR;
 
   MockGaiaOAuthClientDelegate delegate;
   EXPECT_CALL(delegate, OnNetworkError(response_code))
       .Times(1);
 
@@ skipping 112 matching lines @@
   MockGaiaOAuthClientDelegate delegate;
   EXPECT_CALL(delegate, OnGetUserInfoResponsePtr(_))
       .WillOnce(SaveArg<0>(&captured_result));
 
   MockOAuthFetcherFactory factory;
   factory.set_results(kDummyFullUserInfoResult);
 
   GaiaOAuthClient auth(GetRequestContext());
   auth.GetUserInfo("access_token", 1, &delegate);
 
-  scoped_ptr<base::Value> value =
+  std::unique_ptr<base::Value> value =
       base::JSONReader::Read(kDummyFullUserInfoResult);
   DCHECK(value);
   ASSERT_TRUE(value->IsType(base::Value::TYPE_DICTIONARY));
   base::DictionaryValue* expected_result;
   value->GetAsDictionary(&expected_result);
 
   ASSERT_TRUE(expected_result->Equals(captured_result));
 }
 
 TEST_F(GaiaOAuthClientTest, GetTokenInfo) {
@@ skipping 26 matching lines @@
 
   GaiaOAuthClient auth(GetRequestContext());
   auth.GetTokenHandleInfo("some_handle", 1, &delegate);
 
   std::string audience;
   ASSERT_TRUE(captured_result->GetString("audience", &audience));
   ASSERT_EQ("1234567890.apps.googleusercontent.com", audience);
 }
 
 }  // namespace gaia