Third Party Authentication for Android Part II - Java Native Interface plumbing

remoting/client/jni/chromoting_jni_instance.h

 // Copyright 2013 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 REMOTING_CLIENT_CHROMOTING_JNI_INSTANCE_H_
 #define REMOTING_CLIENT_CHROMOTING_JNI_INSTANCE_H_
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/client_user_interface.h"
 #include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/client/jni/jni_frame_consumer.h"
-#include "remoting/client/token_fetcher_proxy.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/cursor_shape_stub.h"
 
 namespace remoting {
 
 namespace protocol {
 class ClipboardEvent;
 class CursorShapeInfo;
 }  // namespace protocol
 
 namespace client {
 class LogToServer;
 }
 
 class VideoRenderer;
+class TokenFetcherProxy;
 
 // ClientUserInterface that indirectly makes and receives JNI calls.
 class ChromotingJniInstance
   : public ClientUserInterface,
     public protocol::ClipboardStub,
     public protocol::CursorShapeStub,
     public base::RefCountedThreadSafe<ChromotingJniInstance> {
  public:
   // Initiates a connection with the specified host. Call from the UI thread.
   // The instance does not take ownership of |jni_runtime|. To connect with an
@@ skipping 11 matching lines @@
   // up. Must be called before destruction.
   void Cleanup();
 
   // Requests the android app to fetch a third-party token.
   void FetchThirdPartyToken(
       const GURL& token_url,
       const std::string& client_id,
       const std::string& scope,
       const base::WeakPtr<TokenFetcherProxy> token_fetcher_proxy);
 
+  // Called by the android app when the token is fetched.
+  void HandleOnThirdPartyTokenFetched(const std::string& token,
+                                      const std::string& shared_secret);
+
   // Provides the user's PIN and resumes the host authentication attempt. Call
   // on the UI thread once the user has finished entering this PIN into the UI,
   // but only after the UI has been asked to provide a PIN (via FetchSecret()).
   void ProvideSecret(const std::string& pin, bool create_pair,
                      const std::string& device_name);
 
   // Schedules a redraw on the display thread. May be called from any thread.
   void RedrawDesktop();
 
   // Moves the host's cursor to the specified coordinates, optionally with some
@@ skipping 75 matching lines @@
 
   // This group of variables is to be used on the network thread.
   ClientConfig client_config_;
   scoped_ptr<ClientContext> client_context_;
   scoped_ptr<VideoRenderer> video_renderer_;
   scoped_ptr<protocol::ConnectionToHost> connection_;
   scoped_ptr<ChromotingClient> client_;
   XmppSignalStrategy::XmppServerConfig xmpp_config_;
   scoped_ptr<XmppSignalStrategy> signaling_;  // Must outlive client_
   scoped_ptr<client::LogToServer> log_to_server_;
+  base::WeakPtr<TokenFetcherProxy> token_fetcher_proxy_;
 
   // Pass this the user's PIN once we have it. To be assigned and accessed on
   // the UI thread, but must be posted to the network thread to call it.
   protocol::SecretFetchedCallback pin_callback_;
 
   // Indicates whether to establish a new pairing with this host. This is
   // modified in ProvideSecret(), but thereafter to be used only from the
   // network thread. (This is safe because ProvideSecret() is invoked at most
   // once per run, and always before any reference to this flag.)
   bool create_pairing_;
 
   // The device name to appear in the paired-clients list. Accessed on the
   // network thread.
   std::string device_name_;
 
   // If this is true, performance statistics will be periodically written to
   // the Android log. Used on the network thread.
   bool stats_logging_enabled_;
 
   friend class base::RefCountedThreadSafe<ChromotingJniInstance>;
 
+  base::WeakPtrFactory<ChromotingJniInstance> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(ChromotingJniInstance);
 };
 
 }  // namespace remoting
 
 #endif