Adding the AccessTokenFetcher and Environment class to the app remoting test

remoting/test/app_remoting_test_driver_environment.cc

Index: remoting/test/app_remoting_test_driver_environment.cc
diff --git a/remoting/test/app_remoting_test_driver_environment.cc b/remoting/test/app_remoting_test_driver_environment.cc
new file mode 100644
index 0000000000000000000000000000000000000000..09532b661e9e1a704e8d3f920dfd23f844f82061
--- /dev/null
+++ b/remoting/test/app_remoting_test_driver_environment.cc
@@ -0,0 +1,172 @@
+// Copyright 2015 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 "remoting/test/app_remoting_test_driver_environment.h"
+
+#include "base/bind.h"
+#include "base/callback_forward.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+
+namespace remoting {
+namespace test {
+
+AppRemotingTestDriverEnvironment* AppRemotingSharedData;
+
+AppRemotingTestDriverEnvironment::AppRemotingTestDriverEnvironment(
+    const std::string& user_name,
+    const std::string& service_environment)
+    : user_name_(user_name),
+      service_environment_(service_environment) {
+  DCHECK(!user_name_.empty());
+  DCHECK(!service_environment.empty());
+}
+
+AppRemotingTestDriverEnvironment::~AppRemotingTestDriverEnvironment() {
+}
+
+bool AppRemotingTestDriverEnvironment::Initialize(
+    const std::string& auth_code) {
+  if (!access_token_.empty()) {
+    return true;
+  }
+
+  if (!refresh_token_store_) {
+    refresh_token_store_ = GetRefreshTokenStoreForDisk();
+  }
+
+  // Check to see if we have a refresh token stored for this user.
+  refresh_token_ = refresh_token_store_->ReadRefreshTokenFromDisk(user_name_);
+  if (refresh_token_.empty()) {
+    // This isn't necessarily an error as this might be a first run scenario.
+    DVLOG(1) << "No refresh token stored for " << user_name_;
+
+    if (auth_code.empty()) {
+      // No token and no Auth code means no service connectivity, bail!
+      LOG(ERROR) << "Cannot retrieve an access token without a stored refresh"
+                 << " token on disk or an auth_code passed into the tool";
+      return false;
+    }
+  }
+
+  if (!RetrieveAccessToken(auth_code)) {
+    // If we cannot retrieve an access token, then nothing is going to work and
+    // we should let the caller know that our object is not ready to be used.
+    return false;
+  }
+
+  return true;
+}
+
+bool AppRemotingTestDriverEnvironment::RefreshAccessToken() {
+  DCHECK(!refresh_token_.empty());
+
+  // Empty auth code is used when refreshing.
+  return RetrieveAccessToken(std::string());
+}
+
+void AppRemotingTestDriverEnvironment::SetAccessTokenFetcherForTest(
+    scoped_ptr<remoting::test::AccessTokenFetcher> mock_fetcher) {
+  mock_access_token_fetcher_ = mock_fetcher.Pass();
+}
+
+void AppRemotingTestDriverEnvironment::SetRefreshTokenStoreForTest(
+    scoped_ptr<remoting::test::RefreshTokenStoreInterface> mock_token_store) {
+  refresh_token_store_ = mock_token_store.Pass();
+}
+
+void AppRemotingTestDriverEnvironment::SetUp() {

[Wez, 2015/02/19 22:00:23]

Do you need these at all, now that they are empty?

[joedow, 2015/02/20 02:58:36]

Done.

+}
+
+void AppRemotingTestDriverEnvironment::TearDown() {
+}
+
+bool AppRemotingTestDriverEnvironment::RetrieveAccessToken(
+    const std::string& auth_code) {
+  scoped_ptr<base::MessageLoopForIO> message_loop;
+
+  if (!base::MessageLoop::current()) {
+    // Create a temporary message loop if the current thread does not already
+    // have one so we can use its task runner for our network request.
+    message_loop.reset(new base::MessageLoopForIO);
+  }
+
+  base::RunLoop network_request_run_loop;

[Wez, 2015/02/19 22:00:23]

nit: Just run_loop?

[joedow, 2015/02/20 02:58:36]

Done.

+
+  access_token_.clear();
+
+  AccessTokenCallback access_token_callback =
+      base::Bind(&AppRemotingTestDriverEnvironment::OnAccessTokenRetrieved,
+                 base::Unretained(this),
+                 network_request_run_loop.QuitClosure());
+
+  scoped_ptr<remoting::test::AccessTokenFetcher> access_token_fetcher;
+  if (!mock_access_token_fetcher_) {
+    access_token_fetcher.reset(new remoting::test::AccessTokenFetcher());
+  } else {
+    access_token_fetcher.reset(mock_access_token_fetcher_.get());

[Wez, 2015/02/19 22:00:23]

This is a risky construct; instead of taking ownership of
mock_access_token_fetcher_ and later releasing it, I'd suggest something like:

scoped_ptr<AccessTokenFetcher> temporary_access_token_fetcher;
AccessTokenFetcher* access_token_fetcher = access_token_fetcher_for_test_;
if (!access_token_fetcher) {
  temporary_access_token_fetcher.reset(...);
  access_token_fetcher = ...;
}

.. do some work ..

i.e. only "own" a local temporary AccessTokenFetcher, otherwise just use
whatever was was passed in via ...ForTest().

[joedow, 2015/02/20 02:58:36]

Done.

+  }
+
+  if (!auth_code.empty()) {
+    // If the user passed in an authcode, then use it to retrieve an
+    // updated access/refresh token.
+    access_token_fetcher->GetAccessTokenFromAuthCode(
+        auth_code,
+        access_token_callback);
+  } else {
+    DCHECK(!refresh_token_.empty());
+
+    access_token_fetcher->GetAccessTokenFromRefreshToken(
+        refresh_token_,
+        access_token_callback);
+  }
+
+  network_request_run_loop.Run();
+
+  // If we are using the mock access token fetcher, then release it here so it
+  // is not destroyed at the end of the function.
+  if (mock_access_token_fetcher_) {
+    ignore_result(access_token_fetcher.release());
+  }
+
+  // If we were using an auth_code and received a valid refresh token,
+  // then we want to store it locally.  If we had an auth code and did not
+  // receive a refresh token, then we should let the user know and exit.
+  if (!auth_code.empty()) {
+    if (!refresh_token_.empty()) {
+      if (!refresh_token_store_->WriteRefreshTokenToDisk(
+              user_name_,
+              refresh_token_)) {
+        // If we failed to persist the refresh token, then we should let the
+        // user sort out the issue before continuing.
+        return false;
+      }
+    } else {
+      LOG(ERROR) << "Failed to use AUTH CODE to retrieve a refresh token.\n"
+                 << "Was the one-time use AUTH CODE used more than once?";
+      return false;
+    }
+  }
+
+  if (access_token_.empty()) {
+    LOG(ERROR) << "Failed to retrieve access token.";
+    return false;
+  }
+
+  return true;
+}
+
+void AppRemotingTestDriverEnvironment::OnAccessTokenRetrieved(
+    base::Closure run_loop_quit_closure,
+    const std::string& access_token,
+    const std::string& refresh_token) {
+  access_token_ = access_token;
+  refresh_token_ = refresh_token;
+
+  run_loop_quit_closure.Run();
+}
+
+}  // namespace test
+}  // namespace remoting