Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/gaia/oauth2_mint_token_flow_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 OAuth2MintTokenFlow.
 
+#include "google_apis/gaia/oauth2_mint_token_flow.h"
+
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_access_token_fetcher.h"
-#include "google_apis/gaia/oauth2_mint_token_flow.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::TestURLFetcher;
 using net::URLFetcher;
 using net::URLRequestStatus;
 using testing::_;
@@ skipping 143 matching lines @@
     std::string ext_id = "ext1";
     std::string client_id = "client1";
     std::vector<std::string> scopes(CreateTestScopes());
     flow_.reset(new MockMintTokenFlow(
         delegate, OAuth2MintTokenFlow::Parameters(ext_id, client_id, scopes,
                                                   device_id, mode)));
   }
 
   // Helper to parse the given string to DictionaryValue.
   static base::DictionaryValue* ParseJson(const std::string& str) {
-    scoped_ptr<base::Value> value = base::JSONReader::Read(str);
+    std::unique_ptr<base::Value> value = base::JSONReader::Read(str);
     EXPECT_TRUE(value.get());
     EXPECT_EQ(base::Value::TYPE_DICTIONARY, value->GetType());
     return static_cast<base::DictionaryValue*>(value.release());
   }
 
-  scoped_ptr<MockMintTokenFlow> flow_;
+  std::unique_ptr<MockMintTokenFlow> flow_;
   StrictMock<MockDelegate> delegate_;
 };
 
 TEST_F(OAuth2MintTokenFlowTest, CreateApiCallBody) {
   {  // Issue advice mode.
     CreateFlow(OAuth2MintTokenFlow::MODE_ISSUE_ADVICE);
     std::string body = flow_->CreateApiCallBody();
     std::string expected_body(
         "force=false"
         "&response_type=none"
@@ skipping 46 matching lines @@
         "&origin=ext1"
         "&device_id=device_id1"
         "&device_type=chrome"
         "&lib_ver=extension");
     EXPECT_EQ(expected_body, body);
   }
 }
 
 TEST_F(OAuth2MintTokenFlowTest, ParseMintTokenResponse) {
   {  // Access token missing.
-    scoped_ptr<base::DictionaryValue> json(
+    std::unique_ptr<base::DictionaryValue> json(
         ParseJson(kTokenResponseNoAccessToken));
     std::string at;
     int ttl;
     EXPECT_FALSE(OAuth2MintTokenFlow::ParseMintTokenResponse(json.get(), &at,
                                                              &ttl));
     EXPECT_TRUE(at.empty());
   }
   {  // All good.
-    scoped_ptr<base::DictionaryValue> json(ParseJson(kValidTokenResponse));
+    std::unique_ptr<base::DictionaryValue> json(ParseJson(kValidTokenResponse));
     std::string at;
     int ttl;
     EXPECT_TRUE(OAuth2MintTokenFlow::ParseMintTokenResponse(json.get(), &at,
                                                             &ttl));
     EXPECT_EQ("at1", at);
     EXPECT_EQ(3600, ttl);
   }
 }
 
 TEST_F(OAuth2MintTokenFlowTest, ParseIssueAdviceResponse) {
   {  // Description missing.
-    scoped_ptr<base::DictionaryValue> json(
+    std::unique_ptr<base::DictionaryValue> json(
         ParseJson(kIssueAdviceResponseNoDescription));
     IssueAdviceInfo ia;
     EXPECT_FALSE(OAuth2MintTokenFlow::ParseIssueAdviceResponse(
         json.get(), &ia));
     EXPECT_TRUE(ia.empty());
   }
   {  // Detail missing.
-    scoped_ptr<base::DictionaryValue> json(
+    std::unique_ptr<base::DictionaryValue> json(
         ParseJson(kIssueAdviceResponseNoDetail));
     IssueAdviceInfo ia;
     EXPECT_FALSE(OAuth2MintTokenFlow::ParseIssueAdviceResponse(
         json.get(), &ia));
     EXPECT_TRUE(ia.empty());
   }
   {  // All good.
-    scoped_ptr<base::DictionaryValue> json(
+    std::unique_ptr<base::DictionaryValue> json(
         ParseJson(kValidIssueAdviceResponse));
     IssueAdviceInfo ia;
     EXPECT_TRUE(OAuth2MintTokenFlow::ParseIssueAdviceResponse(
         json.get(), &ia));
     IssueAdviceInfo ia_expected(CreateIssueAdvice());
     EXPECT_EQ(ia_expected, ia);
   }
 }
 
 TEST_F(OAuth2MintTokenFlowTest, ProcessApiCallSuccess) {
@@ skipping 58 matching lines @@
   }
 
   {  // Non-null delegate.
     TestURLFetcher url_fetcher(1, GURL("http://www.google.com"), NULL);
     url_fetcher.set_status(URLRequestStatus::FromError(net::ERR_FAILED));
     CreateFlow(OAuth2MintTokenFlow::MODE_MINT_TOKEN_NO_FORCE);
     EXPECT_CALL(delegate_, OnMintTokenFailure(_));
     flow_->ProcessApiCallFailure(&url_fetcher);
   }
 }