Identity API: getAuthToken request queues (token cache prelude)

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/stringprintf.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"
@@ skipping 20 matching lines @@
 
 namespace extensions {
 
 namespace {
 
 namespace errors = identity_constants;
 namespace utils = extension_function_test_utils;
 
 static const char kAccessToken[] = "auth_token";
 
+// This helps us be able to wait until an AsyncExtensionFunction calls
+// SendResponse.
+class SendResponseDelegate
+    : public UIThreadExtensionFunction::DelegateForTests {
+ public:
+  SendResponseDelegate() : should_post_quit_(false) {}
+
+  virtual ~SendResponseDelegate() {}
+
+  void set_should_post_quit(bool should_quit) {
+    should_post_quit_ = should_quit;
+  }
+
+  bool HasResponse() {
+    return response_.get() != NULL;
+  }
+
+  bool GetResponse() {
+    EXPECT_TRUE(HasResponse());
+    return *response_.get();
+  }
+
+  virtual void OnSendResponse(UIThreadExtensionFunction* function,
+                              bool success,
+                              bool bad_message) OVERRIDE {
+    ASSERT_FALSE(bad_message);
+    ASSERT_FALSE(HasResponse());
+    response_.reset(new bool);
+    *response_ = success;
+    if (should_post_quit_) {
+      MessageLoopForUI::current()->Quit();
+    }
+  }
+
+ private:
+  scoped_ptr<bool> response_;
+  bool should_post_quit_;
+};
+
+class AsyncExtensionBrowserTest : public ExtensionBrowserTest {
+ protected:
+  // Asynchronous function runner allows tests to manipulate the browser window
+  // after the call happens.
+  void RunFunctionAsync(
+      UIThreadExtensionFunction* function,
+      const std::string& args) {
+    response_delegate_.reset(new SendResponseDelegate);
+    function->set_test_delegate(response_delegate_.get());
+    scoped_ptr<base::ListValue> parsed_args(utils::ParseList(args));
+    EXPECT_TRUE(parsed_args.get()) <<
+        "Could not parse extension function arguments: " << args;
+    function->SetArgs(parsed_args.get());
+
+    if (!function->GetExtension()) {
+      scoped_refptr<Extension> empty_extension(
+          utils::CreateEmptyExtension());
+      function->set_extension(empty_extension.get());
+    }
+
+    function->set_profile(browser()->profile());
+    function->set_has_callback(true);
+    function->Run();
+  }
+
+  std::string WaitForError(UIThreadExtensionFunction* function) {
+    RunMessageLoopUntilResponse();
+    EXPECT_FALSE(function->GetResultList()) << "Did not expect a result";
+    return function->GetError();
+  }
+
+  base::Value* WaitForSingleResult(UIThreadExtensionFunction* function) {
+    RunMessageLoopUntilResponse();
+    EXPECT_TRUE(function->GetError().empty()) << "Unexpected error: "
+                                              << function->GetError();
+    const base::Value* single_result = NULL;
+    if (function->GetResultList() != NULL &&
+        function->GetResultList()->Get(0, &single_result)) {
+      return single_result->DeepCopy();
+    }
+    return NULL;
+  }
+
+ private:
+  void RunMessageLoopUntilResponse() {
+    // If the RunImpl of |function| didn't already call SendResponse, run the
+    // message loop until they do.
+    if (!response_delegate_->HasResponse()) {
+      response_delegate_->set_should_post_quit(true);
+      content::RunMessageLoop();
+    }
+    EXPECT_TRUE(response_delegate_->HasResponse());
+  }
+
+  scoped_ptr<SendResponseDelegate> response_delegate_;
+};
+
 class TestOAuth2MintTokenFlow : public OAuth2MintTokenFlow {
  public:
   enum ResultType {
     ISSUE_ADVICE_SUCCESS,
     MINT_TOKEN_SUCCESS,
     MINT_TOKEN_FAILURE,
     MINT_TOKEN_BAD_CREDENTIALS
   };
 
   TestOAuth2MintTokenFlow(ResultType result,
@@ skipping 26 matching lines @@
         break;
       }
     }
   }
 
  private:
   ResultType result_;
   OAuth2MintTokenFlow::Delegate* delegate_;
 };
 
+ProfileKeyedService* IdentityAPITestFactory(Profile* profile) {
+  return new IdentityAPI(profile);
+}
+
 }  // namespace
 
 class MockGetAuthTokenFunction : public IdentityGetAuthTokenFunction {
  public:
   MockGetAuthTokenFunction() : login_ui_result_(true),
                                install_ui_result_(false),
                                login_ui_shown_(false),
                                install_ui_shown_(false) {
   }
 
@@ skipping 38 matching lines @@
                OAuth2MintTokenFlow* (OAuth2MintTokenFlow::Mode mode));
 
  private:
   ~MockGetAuthTokenFunction() {}
   bool login_ui_result_;
   bool install_ui_result_;
   bool login_ui_shown_;
   bool install_ui_shown_;
 };
 
-class GetAuthTokenFunctionTest : public ExtensionBrowserTest {
+class MockQueuedMintRequest : public IdentityMintRequestQueue::Request {
+ public:
+  MOCK_METHOD1(StartMintToken, void(IdentityMintRequestQueue::MintType));
+};
+
+class GetAuthTokenFunctionTest : public AsyncExtensionBrowserTest {
  protected:
   enum OAuth2Fields {
     NONE = 0,
     CLIENT_ID = 1,
     SCOPES = 2
   };
 
   virtual ~GetAuthTokenFunctionTest() {}
 
   // Helper to create an extension with specific OAuth2Info fields set.
   // |fields_to_set| should be computed by using fields of Oauth2Fields enum.
   const Extension* CreateExtension(int fields_to_set) {
     const Extension* ext = LoadExtension(
         test_data_dir_.AppendASCII("platform_apps/oauth2"));
     OAuth2Info& oauth2_info = const_cast<OAuth2Info&>(
         OAuth2Info::GetOAuth2Info(ext));
     if ((fields_to_set & CLIENT_ID) != 0)
       oauth2_info.client_id = "client1";
     if ((fields_to_set & SCOPES) != 0) {
       oauth2_info.scopes.push_back("scope1");
       oauth2_info.scopes.push_back("scope2");
     }
     return ext;
   }
+
+  void InitializeTestAPIFactory() {
+    IdentityAPI::GetFactoryInstance()->SetTestingFactory(
+        browser()->profile(), &IdentityAPITestFactory);
+  }
 };
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
                        NoClientId) {
   scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
   func->set_extension(CreateExtension(SCOPES));
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{}]", browser());
   EXPECT_EQ(std::string(errors::kInvalidClientId), error);
   EXPECT_FALSE(func->login_ui_shown());
@@ skipping 274 matching lines @@
       .WillOnce(Return(flow2));
 
   func->set_install_ui_result(true);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{\"interactive\": true}]", browser());
   EXPECT_TRUE(StartsWithASCII(error, errors::kAuthFailure, false));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_TRUE(func->install_ui_shown());
 }
 
-// This helps us be able to wait until an AsyncExtensionFunction calls
-// SendResponse.
-class SendResponseDelegate
-    : public UIThreadExtensionFunction::DelegateForTests {
- public:
-  SendResponseDelegate() : should_post_quit_(false) {}
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, NoninteractiveQueue) {
+  InitializeTestAPIFactory();
+  scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  func->set_extension(extension);
 
-  virtual ~SendResponseDelegate() {}
+  // Create a fake request to block the queue.
+  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension);
+  std::set<std::string> scopes(oauth2_info.scopes.begin(),
+                               oauth2_info.scopes.end());
+  IdentityAPI* id_api =
+      extensions::IdentityAPI::GetFactoryInstance()->GetForProfile(
+          browser()->profile());
+  IdentityMintRequestQueue* queue = id_api->mint_queue();
+  MockQueuedMintRequest queued_request;
+  IdentityMintRequestQueue::MintType type =
+      IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE;
 
-  void set_should_post_quit(bool should_quit) {
-    should_post_quit_ = should_quit;
-  }
+  EXPECT_CALL(queued_request, StartMintToken(type)).Times(1);
+  queue->RequestStart(type, extension->id(), scopes, &queued_request);
 
-  bool HasResponse() {
-    return response_.get() != NULL;
-  }
+  // The real request will start processing, but wait in the queue behind
+  // the blocker.
+  EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(true));
+  RunFunctionAsync(func, "[{}]");
+  // Verify that we have fetched the login token at this point.
+  testing::Mock::VerifyAndClearExpectations(func);
 
-  bool GetResponse() {
-    EXPECT_TRUE(HasResponse());
-    return *response_.get();
-  }
+  // The flow will be created after the first queued request clears.
+  TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
 
-  virtual void OnSendResponse(UIThreadExtensionFunction* function,
-                              bool success,
-                              bool bad_message) OVERRIDE {
-    ASSERT_FALSE(bad_message);
-    ASSERT_FALSE(HasResponse());
-    response_.reset(new bool);
-    *response_ = success;
-    if (should_post_quit_) {
-      MessageLoopForUI::current()->Quit();
-    }
-  }
+  queue->RequestComplete(type, extension->id(), scopes, &queued_request);
 
- private:
-  scoped_ptr<bool> response_;
-  bool should_post_quit_;
-};
+  scoped_ptr<base::Value> value(WaitForSingleResult(func));
+  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());
+}
 
-class LaunchWebAuthFlowFunctionTest : public ExtensionBrowserTest {
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, InteractiveQueue) {
+  InitializeTestAPIFactory();
+  scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  func->set_extension(extension);
+
+  // Create a fake request to block the queue.
+  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension);
+  std::set<std::string> scopes(oauth2_info.scopes.begin(),
+                               oauth2_info.scopes.end());
+  IdentityAPI* id_api =
+      extensions::IdentityAPI::GetFactoryInstance()->GetForProfile(
+          browser()->profile());
+  IdentityMintRequestQueue* queue = id_api->mint_queue();
+  MockQueuedMintRequest queued_request;
+  IdentityMintRequestQueue::MintType type =
+      IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE;
+
+  EXPECT_CALL(queued_request, StartMintToken(type)).Times(1);
+  queue->RequestStart(type, extension->id(), scopes, &queued_request);
+
+  // The real request will start processing, but wait in the queue behind
+  // the blocker.
+  EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow1 = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow1));
+  RunFunctionAsync(func, "[{\"interactive\": true}]");
+  // Verify that we have fetched the login token and run the first flow.
+  testing::Mock::VerifyAndClearExpectations(func);
+  EXPECT_FALSE(func->install_ui_shown());
+
+  // The UI will be displayed and the second flow will be created
+  // after the first queued request clears.
+  func->set_install_ui_result(true);
+  TestOAuth2MintTokenFlow* flow2 = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow2));
+
+  queue->RequestComplete(type, extension->id(), scopes, &queued_request);
+
+  scoped_ptr<base::Value> value(WaitForSingleResult(func));
+  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());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveQueuedNoninteractiveFails) {
+  InitializeTestAPIFactory();
+  scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  func->set_extension(extension);
+
+  // Create a fake request to block the interactive queue.
+  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension);
+  std::set<std::string> scopes(oauth2_info.scopes.begin(),
+                               oauth2_info.scopes.end());
+  IdentityAPI* id_api =
+      extensions::IdentityAPI::GetFactoryInstance()->GetForProfile(
+          browser()->profile());
+  IdentityMintRequestQueue* queue = id_api->mint_queue();
+  MockQueuedMintRequest queued_request;
+  IdentityMintRequestQueue::MintType type =
+      IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE;
+
+  EXPECT_CALL(queued_request, StartMintToken(type)).Times(1);
+  queue->RequestStart(type, extension->id(), scopes, &queued_request);
+
+  // Non-interactive requests fail without hitting GAIA, because a
+  // consent UI is known to be up.
+  EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(true));
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{}]", browser());
+  EXPECT_EQ(std::string(errors::kNoGrant), error);
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_FALSE(func->install_ui_shown());
+
+  queue->RequestComplete(type, extension->id(), scopes, &queued_request);
+}
+
+class LaunchWebAuthFlowFunctionTest : public AsyncExtensionBrowserTest {
  protected:
   void RunAndCheckBounds(
       const std::string& extra_params,
       int expected_x,
       int expected_y,
       int expected_width,
       int expected_height) {
     content::WindowedNotificationObserver observer(
         chrome::NOTIFICATION_BROWSER_WINDOW_READY,
         content::NotificationService::AllSources());
@@ skipping 13 matching lines @@
     Browser* web_auth_flow_browser =
         content::Source<Browser>(observer.source()).ptr();
     EXPECT_EQ(expected_x, web_auth_flow_browser->override_bounds().x());
     EXPECT_EQ(expected_y, web_auth_flow_browser->override_bounds().y());
     EXPECT_EQ(expected_width, web_auth_flow_browser->override_bounds().width());
     EXPECT_EQ(
         expected_height, web_auth_flow_browser->override_bounds().height());
 
     web_auth_flow_browser->window()->Close();
   }
-
-  // Asynchronous function runner allows tests to manipulate the browser window
-  // after the call happens.
-  void RunFunctionAsync(
-      UIThreadExtensionFunction* function,
-      const std::string& args) {
-    response_delegate_.reset(new SendResponseDelegate);
-    function->set_test_delegate(response_delegate_.get());
-    scoped_ptr<base::ListValue> parsed_args(utils::ParseList(args));
-    EXPECT_TRUE(parsed_args.get()) <<
-        "Could not parse extension function arguments: " << args;
-    function->SetArgs(parsed_args.get());
-
-    scoped_refptr<Extension> empty_extension(
-        utils::CreateEmptyExtension());
-    function->set_extension(empty_extension.get());
-
-    function->set_profile(browser()->profile());
-    function->set_has_callback(true);
-    function->Run();
-  }
-
-  std::string WaitForError(UIThreadExtensionFunction* function) {
-    // If the RunImpl of |function| didn't already call SendResponse, run the
-    // message loop until they do.
-    if (!response_delegate_->HasResponse()) {
-      response_delegate_->set_should_post_quit(true);
-      content::RunMessageLoop();
-    }
-
-    EXPECT_TRUE(response_delegate_->HasResponse());
-    return function->GetError();
-  }
-
- private:
-  scoped_ptr<SendResponseDelegate> response_delegate_;
 };
 
 IN_PROC_BROWSER_TEST_F(LaunchWebAuthFlowFunctionTest, Bounds) {
   RunAndCheckBounds(std::string(), 0, 0, 0, 0);
   RunAndCheckBounds("\"width\": 100, \"height\": 200", 0, 0, 100, 200);
   RunAndCheckBounds("\"left\": 100, \"top\": 200", 100, 200, 0, 0);
   RunAndCheckBounds(
       "\"left\": 100, \"top\": 200, \"width\": 300, \"height\": 400",
       100, 200, 300, 400);
 }
@@ skipping 117 matching lines @@
       "https://abcdefghij.chromiumapp.org/callback#test')</script>\"}]",
       browser()));
 
   std::string url;
   EXPECT_TRUE(value->GetAsString(&url));
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 }  // namespace extensions