arc: Use incognito profile for OptIn and cookie fetcher

chrome/browser/chromeos/arc/arc_auth_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_ARC_ARC_AUTH_SERVICE_H_
 #define CHROME_BROWSER_CHROMEOS_ARC_ARC_AUTH_SERVICE_H_
 
 #include <ostream>
 
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/chromeos/arc/arc_auth_ui.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service.h"
 #include "components/arc/auth/arc_auth_fetcher.h"
 #include "components/arc/common/auth.mojom.h"
 #include "components/prefs/pref_change_registrar.h"
+#include "google_apis/gaia/gaia_auth_consumer.h"
+#include "google_apis/gaia/ubertoken_fetcher.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "net/cookies/canonical_cookie.h"
 
+class GaiaAuthFetcher;
 class PrefService;
 class Profile;
 
+namespace net {
+class URLRequestContextGetter;
+}
+
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
 namespace arc {
 
 // This class proxies the request from the client to fetch an auth code from
 // LSO.
 class ArcAuthService : public ArcService,
                        public AuthHost,
                        public ArcBridgeService::Observer,
                        public ArcAuthFetcher::Delegate,
-                       public ArcAuthUI::Delegate {
+                       public ArcAuthUI::Delegate,
+                       public UbertokenConsumer,
+                       public GaiaAuthConsumer {
  public:
   enum class State {
     DISABLE,        // ARC is not allowed to run (default).
     FETCHING_CODE,  // ARC is allowed, receiving auth_2 code.
     NO_CODE,        // ARC is allowed, auth_2 code was not received.
     ENABLE,         // ARC is allowed, auth_2 code was received.
   };
 
   class Observer {
    public:
@@ skipping 34 matching lines @@
   // Overrides AuthHost.  For security reason this code can be used only
   // once and exists for specific period of time.
   void GetAuthCode(const GetAuthCodeCallback& callback) override;
 
   // ArcAuthFetcher::Delegate:
   void OnAuthCodeFetched(const std::string& auth_code) override;
   void OnAuthCodeNeedUI() override;
   void OnAuthCodeFailed() override;
 
   // ArcAuthUI::Delegate:
+  void OnAuthCodeFetchedFromUI(const std::string& auth_code) override;
   void OnAuthUIClosed() override;
 
+  // UbertokenConsumer:
+  void OnUbertokenSuccess(const std::string& token) override;
+  void OnUbertokenFailure(const GoogleServiceAuthError& error) override;
+
+  // GaiaAuthConsumer:
+  void OnMergeSessionSuccess(const std::string& data) override;
+  void OnMergeSessionFailure(const GoogleServiceAuthError& error) override;
+
  private:
   void FetchAuthCode();
+  void ShowUI();
   void CloseUI();
   void SetState(State state);
   void ShutdownBridgeAndCloseUI();
   void OnOptInPreferenceChanged();
+  void CopyCookiesAndStartFetching();
+  void StartFetcherOnUIThread();
+  void CleanupSigninProfile();
+
+  void StartCopyFromArcCookiesOnIOThread(
+      net::URLRequestContextGetter* context_getter_from,
+      net::URLRequestContextGetter* context_getter_to);
+  void CopyFromArcCookiesOnIOThread(
+      net::URLRequestContextGetter* context_getter,
+      const net::CookieList& cookie_list);
+  void StartCopyToArcCookiesOnIOThread(
+      const std::string& auth_code,
+      net::URLRequestContextGetter* context_getter_from,
+      net::URLRequestContextGetter* context_getter_to);
+  void CopyToArcCookiesOnIOThread(const std::string& auth_code,
+                                  net::URLRequestContextGetter* context_getter,
+                                  const net::CookieList& cookie_list);
 
   // Unowned pointer. Keeps current profile.
   Profile* profile_ = nullptr;
+  // Unowned pointer. Keeps sign-in profile.
+  Profile* signin_profile_ = nullptr;
 
   // Owned by view hierarchy.
   ArcAuthUI* auth_ui_ = nullptr;
 
   // Registrar used to monitor ARC opt-in state.
   PrefChangeRegistrar pref_change_registrar_;
 
   mojo::Binding<AuthHost> binding_;
   base::ThreadChecker thread_checker_;
   State state_ = State::DISABLE;
   base::ObserverList<Observer> observer_list_;
   scoped_ptr<ArcAuthFetcher> auth_fetcher_;
+  scoped_ptr<GaiaAuthFetcher> merger_fetcher_;
+  scoped_ptr<UbertokenFetcher> ubertoken_fethcher_;
   std::string auth_code_;
+  bool signin_profile_dirty_ = false;
+  int retry_cnt_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(ArcAuthService);
 };
 
 std::ostream& operator<<(std::ostream& os, const ArcAuthService::State& state);
 
 }  // namespace arc
 
 #endif  // CHROME_BROWSER_CHROMEOS_ARC_ARC_AUTH_SERVICE_H_