Create an abstract flow class that abstracts the following logical steps of calling an OAuth2 enabl…

chrome/common/net/gaia/oauth2_api_call_flow.h

+// 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.
+
+#ifndef CHROME_COMMON_NET_GAIA_OAUTH2_API_CALL_FLOW_H_
+#define CHROME_COMMON_NET_GAIA_OAUTH2_API_CALL_FLOW_H_
+
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "chrome/common/net/gaia/oauth2_access_token_consumer.h"
+#include "chrome/common/net/gaia/oauth2_access_token_fetcher.h"
+#include "chrome/common/net/gaia/oauth2_mint_token_consumer.h"
+#include "chrome/common/net/gaia/oauth2_mint_token_fetcher.h"
+#include "content/public/common/url_fetcher.h"
+#include "content/public/common/url_fetcher_delegate.h"
+
+class GoogleServiceAuthError;
+class OAuth2MintTokenFlowTest;
+
+namespace net {
+class URLRequestContextGetter;
+}
+
+// Base calss for all classes that implement a flow to call OAuth2
+// enabled APIs.
+//
+// Given: refresh token, access token, list of scopes an OAuth2 enabled
+// API is called in the following way:
+// 1. Try the given access token to call the API.
+// 2. If that does not work, use the refresh token and scopes to generate
+//    a new access token.
+// 3. Try the new access token to call the API.
+//
+// This class abstracts the basic steps and exposes template methods
+// for sub-classes to implement for API specific detials.
+class OAuth2ApiCallFlow
+    : public content::URLFetcherDelegate,
+      public OAuth2AccessTokenConsumer {
+ public:
+  // Creates an instance that works with the given data.
+  // Note that access_token can be empty. In that case, the flow will skip
+  // the first step (of trying an existing acces token).
+  OAuth2ApiCallFlow(
+      net::URLRequestContextGetter* context,
+      const std::string& refresh_token,
+      const std::string& access_token,
+      const std::vector<std::string>& scopes);
+
+  virtual ~OAuth2ApiCallFlow();
+
+  // Start the flow.
+  void Start();
+
+  // OAuth2AccessTokenFetcher implementation.
+  virtual void OnGetTokenSuccess(const std::string& access_token);

[sail, 2012/03/30 17:41:42]

can these 3 functions be private?

[Munjal (Google), 2012/03/30 18:05:41]

No, they are callback methods that are invoked by another class. So can't be
private.

[sail, 2012/03/30 18:08:56]

Even though it's a callback it's ok to make this private. The callback will
still work.

[Munjal (Google), 2012/03/30 19:01:28]

I see. Thanks for that tip.

Even though it might work, I tried it and reverted it back to this for two
reasons:
1. Other Chrome code that implement callbacks seem to keep the inhertied method
pbulic.
2. If I make these private, I have to make the test class a friend. That is not
bizarre by itself. But given #1 it felt inappropriate.

Let me know if you feel strongly though. I am not adamant about this.

+  virtual void OnGetTokenFailure(const GoogleServiceAuthError& error);
+
+  // content::URLFetcherDelegate implementation.
+  void OnURLFetchComplete(const content::URLFetcher* source);
+
+ protected:
+  // Template methods for sub-classes.
+
+  // Methods to help create HTTP request.
+  virtual GURL CreateApiCallUrl() = 0;
+  virtual std::string CreateApiCallBody() = 0;
+
+  // Sub-classes can expose appropriate observer interface by implementing
+  // these template methods.
+  // Called when the API call finished successfully.
+  virtual void ProcessApiCallSuccess(const content::URLFetcher* source) = 0;
+  // Called when the API call failed.
+  virtual void ProcessApiCallFailure(const content::URLFetcher* source) = 0;
+  // Called when a new access token is generated.
+  virtual void ProcessNewAccessToken(const std::string& access_token) = 0;
+  virtual void ProcessMintAccessTokenFailure(
+      const GoogleServiceAuthError& error) = 0;
+
+  // Helper to create an instnace of access token fetcher.
+  // Caller owns the returned instance.
+  virtual OAuth2AccessTokenFetcher* CreateAccessTokenFetcher();

[sail, 2012/03/30 17:41:42]

can we make this private? I don't think anyone needs it right now

[Munjal (Google), 2012/03/30 18:05:41]

This is protected so that Mock implementation in testing can override it. Same
with the one below.

[sail, 2012/03/30 18:08:56]

I think you can mock private functions. See:
http://code.google.com/p/googlemock/wiki/CookBook#Mocking_Private_or_Protecte...

[Munjal (Google), 2012/03/30 19:01:28]

Done.

+
+  // Creates an instance of URLFetcher that does not send or save cookies.
+  // The URLFether's method will be GET if body is empty, POST otherwise.
+  // Caller owns the returned instance.
+  virtual content::URLFetcher* CreateURLFetcher();

[sail, 2012/03/30 17:41:42]

same, I think this could be private

[Munjal (Google), 2012/03/30 18:05:41]

Same comment as above. It is mocked out in testing.

[Munjal (Google), 2012/03/30 19:01:28]

Done.

+
+ private:
+  // The steps this class performs are:
+  // 1. Try existing access token.
+  // 2. If that works, flow is done. If not, generate a new access token.
+  // 3. Try using new access token.
+  enum State {
+    INITIAL,
+    API_CALL_STARTED,
+    API_CALL_DONE,
+    MINT_ACCESS_TOKEN_STARTED,
+    MINT_ACCESS_TOKEN_DONE,
+    ERROR_STATE
+  };
+
+  friend class OAuth2ApiCallFlowTest;
+
+  // Helper methods to implement the state machien for the flow.
+  void BeginApiCall();
+  void EndApiCall(const content::URLFetcher* source);
+  void BeginMintAccessToken();
+  void EndMintAccessToken(const GoogleServiceAuthError* error);
+
+  net::URLRequestContextGetter* context_;
+  std::string refresh_token_;
+  std::string access_token_;
+  std::vector<std::string> scopes_;
+
+  State state_;
+  // Whether we have already tried minting access token once.
+  bool tried_mint_access_token_;
+
+  scoped_ptr<content::URLFetcher> url_fetcher_;
+  scoped_ptr<OAuth2AccessTokenFetcher> oauth2_access_token_fetcher_;
+
+  DISALLOW_COPY_AND_ASSIGN(OAuth2ApiCallFlow);
+};
+
+#endif  // CHROME_COMMON_NET_GAIA_OAUTH2_API_CALL_FLOW_H_