Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/login/saml/saml_browsertest.cc

 // Copyright 2014 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 <cstring>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
@@ skipping 116 matching lines @@
   FakeSamlIdp();
   ~FakeSamlIdp();
 
   void SetUp(const std::string& base_path, const GURL& gaia_url);
 
   void SetLoginHTMLTemplate(const std::string& template_file);
   void SetLoginAuthHTMLTemplate(const std::string& template_file);
   void SetRefreshURL(const GURL& refresh_url);
   void SetCookieValue(const std::string& cookie_value);
 
-  scoped_ptr<HttpResponse> HandleRequest(const HttpRequest& request);
+  std::unique_ptr<HttpResponse> HandleRequest(const HttpRequest& request);
 
  private:
-  scoped_ptr<HttpResponse> BuildHTMLResponse(const std::string& html_template,
-                                             const std::string& relay_state,
-                                             const std::string& next_path);
+  std::unique_ptr<HttpResponse> BuildHTMLResponse(
+      const std::string& html_template,
+      const std::string& relay_state,
+      const std::string& next_path);
 
   base::FilePath html_template_dir_;
 
   std::string login_path_;
   std::string login_auth_path_;
 
   std::string login_html_template_;
   std::string login_auth_html_template_;
   GURL gaia_assertion_url_;
   GURL refresh_url_;
@@ skipping 31 matching lines @@
 }
 
 void FakeSamlIdp::SetRefreshURL(const GURL& refresh_url) {
   refresh_url_ = refresh_url;
 }
 
 void FakeSamlIdp::SetCookieValue(const std::string& cookie_value) {
   cookie_value_ = cookie_value;
 }
 
-scoped_ptr<HttpResponse> FakeSamlIdp::HandleRequest(
+std::unique_ptr<HttpResponse> FakeSamlIdp::HandleRequest(
     const HttpRequest& request) {
   // The scheme and host of the URL is actually not important but required to
   // get a valid GURL in order to parse |request.relative_url|.
   GURL request_url = GURL("http://localhost").Resolve(request.relative_url);
   std::string request_path = request_url.path();
 
   if (request_path == login_path_) {
     std::string relay_state;
     net::GetValueForKeyInQuery(request_url, kRelayState, &relay_state);
     return BuildHTMLResponse(login_html_template_,
                              relay_state,
                              login_auth_path_);
   }
 
   if (request_path != login_auth_path_) {
     // Request not understood.
-    return scoped_ptr<HttpResponse>();
+    return std::unique_ptr<HttpResponse>();
   }
 
   std::string relay_state;
   FakeGaia::GetQueryParameter(request.content, kRelayState, &relay_state);
   GURL redirect_url = gaia_assertion_url_;
 
   if (!login_auth_html_template_.empty()) {
     return BuildHTMLResponse(login_auth_html_template_,
                              relay_state,
                              redirect_url.spec());
   }
 
   redirect_url = net::AppendQueryParameter(
       redirect_url, "SAMLResponse", "fake_response");
   redirect_url = net::AppendQueryParameter(
       redirect_url, kRelayState, relay_state);
 
-  scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
+  std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
   http_response->set_code(net::HTTP_TEMPORARY_REDIRECT);
   http_response->AddCustomHeader("Location", redirect_url.spec());
   http_response->AddCustomHeader(
       "Set-cookie",
       base::StringPrintf("saml=%s", cookie_value_.c_str()));
   return std::move(http_response);
 }
 
-scoped_ptr<HttpResponse> FakeSamlIdp::BuildHTMLResponse(
+std::unique_ptr<HttpResponse> FakeSamlIdp::BuildHTMLResponse(
     const std::string& html_template,
     const std::string& relay_state,
     const std::string& next_path) {
   std::string response_html = html_template;
   base::ReplaceSubstringsAfterOffset(
       &response_html, 0, "$RelayState", relay_state);
   base::ReplaceSubstringsAfterOffset(
       &response_html, 0, "$Post", next_path);
   base::ReplaceSubstringsAfterOffset(
       &response_html, 0, "$Refresh", refresh_url_.spec());
 
-  scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
+  std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
   http_response->set_code(net::HTTP_OK);
   http_response->set_content(response_html);
   http_response->set_content_type("text/html");
 
   return std::move(http_response);
 }
 
 // A FakeCryptohomeClient that stores the salted and hashed secret passed to
 // MountEx().
 class SecretInterceptingFakeCryptohomeClient : public FakeCryptohomeClient {
@@ skipping 49 matching lines @@
         kHTTPSAMLUserEmail,
         embedded_test_server()->base_url().Resolve("/SAML"));
     fake_gaia_->RegisterSamlUser(kDifferentDomainSAMLUserEmail, saml_idp_url);
     fake_gaia_->RegisterSamlDomainRedirectUrl("example.com", saml_idp_url);
 
     OobeBaseTest::SetUpCommandLine(command_line);
   }
 
   void SetUpInProcessBrowserTestFixture() override {
     DBusThreadManager::GetSetterForTesting()->SetCryptohomeClient(
-        scoped_ptr<CryptohomeClient>(cryptohome_client_));
+        std::unique_ptr<CryptohomeClient>(cryptohome_client_));
 
     OobeBaseTest::SetUpInProcessBrowserTestFixture();
   }
 
   void SetUpOnMainThread() override {
     fake_gaia_->SetFakeMergeSessionParams(
         kFirstSAMLUserEmail, kTestAuthSIDCookie1, kTestAuthLSIDCookie1);
 
     embedded_test_server()->RegisterRequestHandler(base::Bind(
         &FakeSamlIdp::HandleRequest, base::Unretained(&fake_saml_idp_)));
@@ skipping 396 matching lines @@
 
   // content::WebContentsObserver:
   void DidFinishLoad(content::RenderFrameHost* render_frame_host,
                      const GURL& validated_url) override;
 
   void WaitForEnrollmentSuccess();
   guest_view::TestGuestViewManager* GetGuestViewManager();
   content::WebContents* GetEnrollmentContents();
 
  private:
-  scoped_ptr<policy::LocalPolicyTestServer> test_server_;
+  std::unique_ptr<policy::LocalPolicyTestServer> test_server_;
   base::ScopedTempDir temp_dir_;
 
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   guest_view::TestGuestViewManagerFactory guest_view_manager_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SAMLEnrollmentTest);
 };
 
 SAMLEnrollmentTest::SAMLEnrollmentTest() {
   guest_view::GuestViewManager::set_factory_for_testing(
       &guest_view_manager_factory_);
   gaia_frame_parent_ = "oauth-enroll-auth-view";
@@ skipping 180 matching lines @@
 SAMLPolicyTest::SAMLPolicyTest()
     : fake_session_manager_client_(new FakeSessionManagerClient),
       device_policy_(test_helper_.device_policy()) {
 }
 
 SAMLPolicyTest::~SAMLPolicyTest() {
 }
 
 void SAMLPolicyTest::SetUpInProcessBrowserTestFixture() {
   DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
-      scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
+      std::unique_ptr<SessionManagerClient>(fake_session_manager_client_));
 
   SamlTest::SetUpInProcessBrowserTestFixture();
 
   // Initialize device policy.
   std::set<std::string> device_affiliation_ids;
   device_affiliation_ids.insert(kAffiliationID);
   policy::affiliation_test_helper::SetDeviceAffiliationID(
       &test_helper_, fake_session_manager_client_, device_affiliation_ids);
 
   // Initialize user policy.
@@ skipping 45 matching lines @@
                   NULL);
   provider_.UpdateChromePolicy(user_policy);
   base::RunLoop().RunUntilIdle();
 }
 
 void SAMLPolicyTest::EnableTransferSAMLCookiesPolicy() {
   em::ChromeDeviceSettingsProto& proto(device_policy_->payload());
   proto.mutable_saml_settings()->set_transfer_saml_cookies(true);
 
   base::RunLoop run_loop;
-  scoped_ptr<CrosSettings::ObserverSubscription> observer =
-      CrosSettings::Get()->AddSettingsObserver(
-           kAccountsPrefTransferSAMLCookies,
-           run_loop.QuitClosure());
+  std::unique_ptr<CrosSettings::ObserverSubscription> observer =
+      CrosSettings::Get()->AddSettingsObserver(kAccountsPrefTransferSAMLCookies,
+                                               run_loop.QuitClosure());
   device_policy_->SetDefaultSigningKey();
   device_policy_->Build();
   fake_session_manager_client_->set_device_policy(device_policy_->GetBlob());
   fake_session_manager_client_->OnPropertyChangeComplete(true);
   run_loop.Run();
 }
 
 void SAMLPolicyTest::SetLoginBehaviorPolicyToSAMLInterstitial() {
   em::ChromeDeviceSettingsProto& proto(device_policy_->payload());
   proto.mutable_login_authentication_behavior()
       ->set_login_authentication_behavior(
           em::LoginAuthenticationBehaviorProto_LoginBehavior_SAML_INTERSTITIAL);
 
   base::RunLoop run_loop;
-  scoped_ptr<CrosSettings::ObserverSubscription> observer =
+  std::unique_ptr<CrosSettings::ObserverSubscription> observer =
       CrosSettings::Get()->AddSettingsObserver(kLoginAuthenticationBehavior,
                                                run_loop.QuitClosure());
   device_policy_->SetDefaultSigningKey();
   device_policy_->Build();
   fake_session_manager_client_->set_device_policy(device_policy_->GetBlob());
   fake_session_manager_client_->OnPropertyChangeComplete(true);
   run_loop.Run();
 }
 
 void SAMLPolicyTest::ShowGAIALoginForm() {
@@ skipping 303 matching lines @@
       chrome::NOTIFICATION_SESSION_STARTED,
       content::NotificationService::AllSources());
 
   OobeScreenWaiter(OobeScreen::SCREEN_CONFIRM_PASSWORD).Wait();
   SendConfirmPassword("fake_password");
   // Login should finish login and a session should start.
   session_start_waiter.Wait();
 }
 
 }  // namespace chromeos