implement sign in dialog

chrome/browser/extensions/api/identity/identity_apitest.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.
 
+#include "base/string_util.h"
+#include "base/values.h"
 #include "chrome/browser/extensions/api/identity/identity_api.h"
 #include "chrome/browser/extensions/api/identity/web_auth_flow.h"
 #include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/extension_function_test_utils.h"
+#include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/net/gaia/oauth2_mint_token_flow.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/test/base/in_process_browser_test.h"
 #include "googleurl/src/gurl.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using extensions::GetAuthTokenFunction;
+using testing::_;
+using testing::Return;
+using testing::ReturnRef;
+
+namespace utils = extension_function_test_utils;
 
 namespace {
 
-class IdentityInterceptor : public OAuth2MintTokenFlow::InterceptorForTests {

[Mihai Parparita -not on Chrome, 2012/07/17 01:01:00]

Can you remove the interceptor support from OAuth2MinTokenFlow and WebAuthFlow,
since these tests were the only uses?

[Munjal (Google), 2012/07/19 22:35:42]

Let me do it in a separate patch.

On 2012/07/17 01:01:00, Mihai Parparita wrote:

[Mihai Parparita -not on Chrome, 2012/07/20 18:02:32]

OK, filed http://crbug.com/138279

+static const char kAccessToken[] = "auth_token";
+
+class TestLoginUI : public LoginUIService::LoginUI {
  public:
-  IdentityInterceptor() : called_(false) { }
-
-  virtual bool DoIntercept(const OAuth2MintTokenFlow* flow,
-                           std::string* access_token,
-                           GoogleServiceAuthError* error) OVERRIDE {
-    *access_token = "auth_token";
-    called_ = true;
-    return true;
-  }
-
-  bool called() const { return called_; }
+  virtual void FocusUI() OVERRIDE {}
+  virtual void CloseUI() OVERRIDE {}
+};
+
+class TestOAuth2MintTokenFlow : public OAuth2MintTokenFlow {
+ public:
+  enum ResultType {
+    ISSUE_ADVICE_SUCCESS,
+    MINT_TOKEN_SUCCESS,
+    MINT_TOKEN_FAILURE
+  };
+
+  TestOAuth2MintTokenFlow(ResultType result,
+                          OAuth2MintTokenFlow::Delegate* delegate)
+    : OAuth2MintTokenFlow(NULL, delegate, OAuth2MintTokenFlow::Parameters()),
+      result_(result),
+      delegate_(delegate) {
+  }
+
+  virtual void Start() OVERRIDE {
+    switch (result_) {
+      case ISSUE_ADVICE_SUCCESS: {
+        IssueAdviceInfo info;
+        delegate_->OnIssueAdviceSuccess(info);
+        break;
+      }
+      case MINT_TOKEN_SUCCESS: {
+        delegate_->OnMintTokenSuccess(kAccessToken);
+        break;
+      }
+      case MINT_TOKEN_FAILURE: {
+        GoogleServiceAuthError error(
+            GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
+        delegate_->OnMintTokenFailure(error);
+        break;
+      }
+    }
+  }
 
  private:
-  bool called_;
+  ResultType result_;
+  OAuth2MintTokenFlow::Delegate* delegate_;
 };
 
-class WebAuthFlowInterceptor
-    : public extensions::WebAuthFlow::InterceptorForTests {
+}  // namespace
+
+class MockGetAuthTokenFunction : public GetAuthTokenFunction {
  public:
-  WebAuthFlowInterceptor() : called_(false) { }
-
-  virtual GURL DoIntercept(const GURL& provider_url) OVERRIDE {
-    called_ = true;
-    return GURL("https://abcd.chromiumapp.org/cb#access_token=tok");
-  }
-
-  bool called() const { return called_; }
-
- private:
-  bool called_;
+  MockGetAuthTokenFunction() : install_ui_result_(false),
+                               login_ui_shown_(false),
+                               install_ui_shown_(false) {
+  }
+
+  void set_install_ui_result(bool result) {
+    install_ui_result_ = result;
+  }
+
+  bool login_ui_shown() const {
+    return login_ui_shown_;
+  }
+
+  bool install_ui_shown() const {
+    return install_ui_shown_;
+  }
+
+  virtual void StartObservingLoginService() OVERRIDE {
+    // Do nothing in tests.
+  }
+  virtual void StopObservingLoginService() OVERRIDE {
+    // Do nothing in tests.
+  }
+
+  virtual void ShowLoginPopup() OVERRIDE {
+    login_ui_shown_ = true;
+    // Explicitly call OnLoginUIClosed.
+    TestLoginUI login_ui;;
+    OnLoginUIClosed(&login_ui);
+  }
+
+  virtual void ShowOAuthApprovalDialog(
+      const IssueAdviceInfo& issue_advice) OVERRIDE {
+    install_ui_shown_ = true;
+    // Call InstallUIProceed or InstallUIAbort based on the flag.
+    if (install_ui_result_)
+      InstallUIProceed();
+    else
+      InstallUIAbort(true);
+  }
+
+  MOCK_CONST_METHOD0(HasLoginToken, bool ());
+  MOCK_CONST_METHOD0(GetExtensionId, const std::string& ());
+  MOCK_CONST_METHOD0(GetOAuth2Info,
+                     const extensions::Extension::OAuth2Info& ());
+  MOCK_METHOD1(CreateMintTokenFlow,
+               OAuth2MintTokenFlow* (OAuth2MintTokenFlow::Mode mode));
+private:
+  bool install_ui_result_;
+  bool login_ui_shown_;
+  bool install_ui_shown_;
 };
 
-}  // namespace
-
-IN_PROC_BROWSER_TEST_F(PlatformAppApiTest, Identity) {
-  IdentityInterceptor id_interceptor;
-  OAuth2MintTokenFlow::SetInterceptorForTests(&id_interceptor);
-  WebAuthFlowInterceptor waf_interceptor;
-  extensions::WebAuthFlow::SetInterceptorForTests(&waf_interceptor);
-  ASSERT_TRUE(RunExtensionTest("identity")) << message_;
-  ASSERT_TRUE(id_interceptor.called());
-  ASSERT_TRUE(waf_interceptor.called());
+class GetAuthTokenFunctionTest : public InProcessBrowserTest {
+protected:
+  void CallOnLoginUIClosed(GetAuthTokenFunction* func,
+                           LoginUIService::LoginUI* login_ui) {
+    func->OnLoginUIClosed(login_ui);
+  }
 };
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       NoClientId) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  EXPECT_CALL(*func.get(), GetOAuth2Info())
+      .WillRepeatedly(ReturnRef(oauth2_info));
+  // Without a callback the function will not generate a result.

[Mihai Parparita -not on Chrome, 2012/07/17 01:01:00]

Instead of having to repeat this every time, can you make
RunFunctionAndReturnResult always do this (I don't think it would affect any
current uses).

[Munjal (Google), 2012/07/19 22:35:42]

Done.

+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{}]", browser());
+  EXPECT_EQ(std::string(GetAuthTokenFunction::kInvalidClientId),
+            error);
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       NoScopes) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  EXPECT_CALL(*func.get(), GetOAuth2Info())
+      .WillRepeatedly(ReturnRef(oauth2_info));
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{}]", browser());
+  EXPECT_EQ(std::string(GetAuthTokenFunction::kInvalidScopes),
+            error);
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       NonInteractiveNotSignedIn) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info())
+      .WillRepeatedly(ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(false));
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{}]", browser());
+  EXPECT_EQ(std::string(GetAuthTokenFunction::kUserNotSignedIn),
+            error);
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       NonInteractiveMintFailure) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info())
+      .WillRepeatedly(ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_FAILURE, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{}]", browser());
+  EXPECT_TRUE(StartsWithASCII(
+      error, GetAuthTokenFunction::kAuthFailure, false));
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       NonInteractiveSuccess) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info())
+      .WillRepeatedly(ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  scoped_ptr<base::Value> value(utils::RunFunctionAndReturnResult(
+      func.get(), "[{}]", browser()));
+  std::string access_token;
+  EXPECT_TRUE(value->GetAsString(&access_token));
+  EXPECT_EQ(std::string(kAccessToken), access_token);
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveLoginCanceled) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info())
+      .WillRepeatedly(ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken()).WillRepeatedly(Return(false));
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{\"interactive\": true}]", browser());
+  EXPECT_EQ(std::string(GetAuthTokenFunction::kUserNotSignedIn),
+            error);
+  EXPECT_TRUE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveLoginSuccessMintFailure) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info()).WillRepeatedly(
+      ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken())
+      .WillOnce(Return(false))
+      .WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_FAILURE, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{\"interactive\": true}]", browser());
+  EXPECT_TRUE(StartsWithASCII(
+      error, GetAuthTokenFunction::kAuthFailure, false));
+  EXPECT_TRUE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveLoginSuccessMintSuccess) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info()).WillRepeatedly(
+      ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken())
+      .WillOnce(Return(false))
+      .WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  scoped_ptr<base::Value> value(utils::RunFunctionAndReturnResult(
+      func.get(), "[{\"interactive\": true}]", browser()));
+  std::string access_token;
+  EXPECT_TRUE(value->GetAsString(&access_token));
+  EXPECT_EQ(std::string(kAccessToken), access_token);
+  EXPECT_TRUE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveLoginSuccessApprovalAborted) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info()).WillRepeatedly(
+      ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken())
+      .WillOnce(Return(false))
+      .WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
+  func->set_install_ui_result(false);
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{\"interactive\": true}]", browser());
+  EXPECT_EQ(std::string(GetAuthTokenFunction::kUserRejected), error);
+  EXPECT_TRUE(func->login_ui_shown());
+  EXPECT_TRUE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveLoginSuccessApprovalDoneMintFailure) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info()).WillRepeatedly(
+      ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken())
+      .WillOnce(Return(false))
+      .WillOnce(Return(true))
+      .WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow1 = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
+  TestOAuth2MintTokenFlow* flow2 = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_FAILURE, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_))
+      .WillOnce(Return(flow1))
+      .WillOnce(Return(flow2));
+
+  func->set_install_ui_result(true);
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{\"interactive\": true}]", browser());
+  EXPECT_TRUE(StartsWithASCII(
+      error, GetAuthTokenFunction::kAuthFailure, false));
+  EXPECT_TRUE(func->login_ui_shown());
+  EXPECT_TRUE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveLoginSuccessApprovalDoneMintSuccess) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info()).WillRepeatedly(
+      ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken())
+      .WillOnce(Return(false))
+      .WillOnce(Return(true))
+      .WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow1 = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
+  TestOAuth2MintTokenFlow* flow2 = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_))
+      .WillOnce(Return(flow1))
+      .WillOnce(Return(flow2));
+
+  func->set_install_ui_result(true);
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  scoped_ptr<base::Value> value(utils::RunFunctionAndReturnResult(
+      func.get(), "[{\"interactive\": true}]", browser()));
+  std::string access_token;
+  EXPECT_TRUE(value->GetAsString(&access_token));
+  EXPECT_EQ(std::string(kAccessToken), access_token);
+  EXPECT_TRUE(func->login_ui_shown());
+  EXPECT_TRUE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveApprovalAborted) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info()).WillRepeatedly(
+      ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken())
+      .WillOnce(Return(true))
+      .WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
+  func->set_install_ui_result(false);
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{\"interactive\": true}]", browser());
+  EXPECT_EQ(std::string(GetAuthTokenFunction::kUserRejected), error);
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_TRUE(func->install_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveApprovalDoneMintSuccess) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  extensions::Extension::OAuth2Info oauth2_info;
+  oauth2_info.client_id = "abcdef";
+  oauth2_info.scopes.push_back("scope1");
+  oauth2_info.scopes.push_back("scope2");
+  EXPECT_CALL(*func.get(), GetOAuth2Info()).WillRepeatedly(
+      ReturnRef(oauth2_info));
+  EXPECT_CALL(*func.get(), HasLoginToken())
+      .WillOnce(Return(true))
+      .WillOnce(Return(true))
+      .WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow1 = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
+  TestOAuth2MintTokenFlow* flow2 = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_))
+      .WillOnce(Return(flow1))
+      .WillOnce(Return(flow2));
+
+  func->set_install_ui_result(true);
+  // Without a callback the function will not generate a result.
+  func->set_has_callback(true);
+  scoped_ptr<base::Value> value(utils::RunFunctionAndReturnResult(
+      func.get(), "[{\"interactive\": true}]", browser()));
+  std::string access_token;
+  EXPECT_TRUE(value->GetAsString(&access_token));
+  EXPECT_EQ(std::string(kAccessToken), access_token);
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_TRUE(func->install_ui_shown());
+}