Client plugin changes to support third party authentication.

remoting/client/plugin/chromoting_instance.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.
 
 // TODO(ajwong): We need to come up with a better description of the
 // responsibilities for each thread.
 
 #ifndef REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
 #define REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
 
@@ skipping 22 matching lines @@
 #include "remoting/client/plugin/mac_key_event_processor.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_plugin_thread_delegate.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/cursor_shape_stub.h"
 #include "remoting/protocol/input_event_tracker.h"
 #include "remoting/protocol/mouse_input_filter.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
+#include "remoting/protocol/third_party_client_authenticator.h"
 
 namespace base {
 class DictionaryValue;
 }  // namespace base
 
 namespace pp {
 class InputEvent;
 class Module;
 }  // namespace pp
 
 namespace remoting {
 
 class ChromotingClient;
 class ChromotingStats;
 class ClientContext;
 class FrameConsumerProxy;
 class PepperAudioPlayer;
+class PepperTokenFetcher;
 class PepperView;
 class PepperXmppProxy;
 class RectangleUpdateDecoder;
 
 struct ClientConfig;
 
 class ChromotingInstance :
       public ClientUserInterface,
       public protocol::ClipboardStub,
       public protocol::CursorShapeStub,
@@ skipping 31 matching lines @@
                     const char* argv[]) OVERRIDE;
   virtual void HandleMessage(const pp::Var& message) OVERRIDE;
   virtual bool HandleInputEvent(const pp::InputEvent& event) OVERRIDE;
 
   // ClientUserInterface interface.
   virtual void OnConnectionState(protocol::ConnectionToHost::State state,
                                  protocol::ErrorCode error) OVERRIDE;
   virtual void OnConnectionReady(bool ready) OVERRIDE;
   virtual protocol::ClipboardStub* GetClipboardStub() OVERRIDE;
   virtual protocol::CursorShapeStub* GetCursorShapeStub() OVERRIDE;
+  virtual scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
+  GetTokenFetcher(const std::string& host_public_key) OVERRIDE;
 
   // protocol::ClipboardStub interface.
   virtual void InjectClipboardEvent(
       const protocol::ClipboardEvent& event) OVERRIDE;
 
   // protocol::CursorShapeStub interface.
   virtual void SetCursorShape(
       const protocol::CursorShapeInfo& cursor_shape) OVERRIDE;
 
   // Called by PepperView.
@@ skipping 19 matching lines @@
   // to it. If this instance is not the currently registered logging instance,
   // then the currently registered instance will stay in effect.
   void UnregisterLoggingInstance();
 
   // A Log Message Handler that is called after each LOG message has been
   // processed. This must be of type LogMessageHandlerFunction defined in
   // base/logging.h.
   static bool LogToUI(int severity, const char* file, int line,
                       size_t message_start, const std::string& str);
 
+  // Requests the webapp to fetch a third-party token.
+  void FetchThirdPartyToken(
+      const GURL& token_url,
+      const std::string& host_public_key,
+      const std::string& scope,
+      const base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ChromotingInstanceTest, TestCaseSetup);
 
   // Used as the |FetchSecretCallback| for IT2Me (or Me2Me from old webapps).
   // Immediately calls |secret_fetched_callback| with |shared_secret|.
   static void FetchSecretFromString(
       const std::string& shared_secret,
       const protocol::SecretFetchedCallback& secret_fetched_callback);
 
   // Message handlers for messages that come from JavaScript. Called
   // from HandleMessage().
   void Connect(const ClientConfig& config);
   void Disconnect();
   void OnIncomingIq(const std::string& iq);
   void ReleaseAllKeys();
   void InjectKeyEvent(const protocol::KeyEvent& event);
   void RemapKey(uint32 in_usb_keycode, uint32 out_usb_keycode);
   void TrapKey(uint32 usb_keycode, bool trap);
   void SendClipboardItem(const std::string& mime_type, const std::string& item);
   void NotifyClientResolution(int width, int height, int x_dpi, int y_dpi);
   void PauseVideo(bool pause);
   void PauseAudio(bool pause);
   void OnPinFetched(const std::string& pin);
+  void OnThirdPartyTokenFetched(const std::string& token,
+                                const std::string& shared_secret);
 
   // Helper method to post messages to the webapp.
   void PostChromotingMessage(const std::string& method,
                              scoped_ptr<base::DictionaryValue> data);
 
   // Posts trapped keys to the web-app to handle.
   void SendTrappedKey(uint32 usb_keycode, bool pressed);
 
   // Callback for PepperXmppProxy.
   void SendOutgoingIq(const std::string& iq);
@@ skipping 37 matching lines @@
   // XmppProxy is a refcounted interface used to perform thread-switching and
   // detaching between objects whose lifetimes are controlled by pepper, and
   // jingle_glue objects. This is used when if we start a sandboxed jingle
   // connection.
   scoped_refptr<PepperXmppProxy> xmpp_proxy_;
 
   // PIN Fetcher.
   bool use_async_pin_dialog_;
   protocol::SecretFetchedCallback secret_fetched_callback_;
 
+  base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher_;
+
   base::WeakPtrFactory<ChromotingInstance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromotingInstance);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_