Clean up Assignment Create in BlimpClientContextImpl.

blimp/client/core/session/identity_source_unittest.cc

 // Copyright 2016 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 "blimp/client/core/session/identity_source.h"
 
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "blimp/client/test/test_blimp_client_context_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::Return;
 
 namespace blimp {
 namespace client {
 namespace {
 
 class MockIdentitySource : public IdentitySource {
  public:
-  explicit MockIdentitySource(BlimpClientContextDelegate* delegate,
-                              const IdentitySource::TokenCallback& callback)
-      : IdentitySource(delegate, callback),
+  MockIdentitySource(
+      std::unique_ptr<IdentityProvider> identity_provider,
+      base::Callback<void(const GoogleServiceAuthError&)> error_callback,
+      const IdentitySource::TokenCallback& callback)
+      : IdentitySource(std::move(identity_provider), error_callback, callback),
         success_(0),
         fail_(0),
         refresh_(0),
         token_callback_count_(0) {}
   ~MockIdentitySource() override{};
 
   void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                          const std::string& access_token,
                          const base::Time& expiration_time) override {
     IdentitySource::OnGetTokenSuccess(request, access_token, expiration_time);
@@ skipping 55 matching lines @@
   IdentitySourceTest() = default;
   ~IdentitySourceTest() override = default;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IdentitySourceTest);
 };
 
 TEST_F(IdentitySourceTest, TestConnect) {
   TestBlimpClientContextDelegate mock_blimp_delegate;
   MockIdentitySource auth(
-      &mock_blimp_delegate,
+      mock_blimp_delegate.CreateIdentityProvider(),
+      base::Bind(&TestBlimpClientContextDelegate::OnAuthenticationError,
+                 base::Unretained(&mock_blimp_delegate)),
       base::Bind(&MockIdentitySource::MockTokenCall, base::Unretained(&auth)));
   FakeIdentityProvider* id_provider =
       static_cast<FakeIdentityProvider*>(auth.GetIdentityProvider());
   FakeOAuth2TokenService* token_service = mock_blimp_delegate.GetTokenService();
 
   // Connect when user is not signed in. Nothing happens.
   id_provider->LogOut();
   auth.Connect();
   DCHECK_EQ(auth.Succeeded(), 0);
   DCHECK_EQ(auth.Failed(), 0);
@@ skipping 65 matching lines @@
   DCHECK_EQ(auth.Refreshed(), 0);
   DCHECK_EQ(auth.TokenCallbackCount(), 1);
   DCHECK_EQ(auth.CallbackToken(), mock_access_token);
 }
 
 // Test retry on token fetching when refresh token is updated during token
 // request.
 TEST_F(IdentitySourceTest, TestConnectRetry) {
   TestBlimpClientContextDelegate mock_blimp_delegate;
   MockIdentitySource auth(
-      &mock_blimp_delegate,
+      mock_blimp_delegate.CreateIdentityProvider(),
+      base::Bind(&TestBlimpClientContextDelegate::OnAuthenticationError,
+                 base::Unretained(&mock_blimp_delegate)),
       base::Bind(&MockIdentitySource::MockTokenCall, base::Unretained(&auth)));
   FakeOAuth2TokenService* token_service = mock_blimp_delegate.GetTokenService();
   FakeIdentityProvider* id_provider =
       static_cast<FakeIdentityProvider*>(auth.GetIdentityProvider());
 
   std::string account = "mock_account";
   std::string mock_access_token = "mock_token";
   id_provider->LogIn(account);
 
   // Prepare refresh token.
@@ skipping 19 matching lines @@
   token_service->IssueAllTokensForAccount(account, mock_access_token, time);
   DCHECK_EQ(auth.Succeeded(), 1);
   DCHECK_EQ(auth.Token(), mock_access_token);
   DCHECK_EQ(auth.TokenCallbackCount(), 1);
   DCHECK_EQ(auth.CallbackToken(), mock_access_token);
 }
 
 TEST_F(IdentitySourceTest, TestConnectFailDelegateCallback) {
   TestBlimpClientContextDelegate mock_blimp_delegate;
   MockIdentitySource auth(
-      &mock_blimp_delegate,
+      mock_blimp_delegate.CreateIdentityProvider(),
+      base::Bind(&TestBlimpClientContextDelegate::OnAuthenticationError,
+                 base::Unretained(&mock_blimp_delegate)),
       base::Bind(&MockIdentitySource::MockTokenCall, base::Unretained(&auth)));
   FakeOAuth2TokenService* token_service = mock_blimp_delegate.GetTokenService();
   FakeIdentityProvider* id_provider =
       static_cast<FakeIdentityProvider*>(auth.GetIdentityProvider());
 
   std::string account = "mock_account";
   std::string mock_access_token = "mock_token";
   id_provider->LogIn(account);
 
   // Prepare refresh token.
   FakeOAuth2TokenServiceDelegate* mock_token_service_delegate =
       token_service->GetFakeOAuth2TokenServiceDelegate();
   mock_token_service_delegate->UpdateCredentials(account, "mock_refresh_token");
 
   // Expect delegate to show error message on non REQUEST_CANCELED errors.
   auth.Connect();
   GoogleServiceAuthError error(
       GoogleServiceAuthError::State::CONNECTION_FAILED);
 
   EXPECT_CALL(mock_blimp_delegate, OnAuthenticationError(error))
       .WillOnce(Return());
   token_service->IssueErrorForAllPendingRequestsForAccount(account, error);
 
   DCHECK_EQ(auth.Failed(), 1);
 }
 
 }  // namespace
 }  // namespace client
 }  // namespace blimp