components/proximity_auth/client_impl.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_PROXIMITY_AUTH_CLIENT_IMPL_H
   6 #define COMPONENTS_PROXIMITY_AUTH_CLIENT_IMPL_H
   7
   8 #include <deque>
   9
  10 #include "base/macros.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/observer_list.h"
  13 #include "components/proximity_auth/client.h"
  14 #include "components/proximity_auth/connection_observer.h"
  15
  16 namespace base {
  17 class DictionaryValue;
  18 }
  19
  20 namespace proximity_auth {
  21
  22 class Connection;
  23 class SecureContext;
  24
  25 // Concrete implementation of the Client interface.
  26 class ClientImpl : public Client, public ConnectionObserver {
  27  public:
  28   // Constructs a client that sends and receives messages over the given
  29   // |connection|, using the |secure_context| to encrypt and decrypt the
  30   // messages. The |connection| must be connected. The client begins observing
  31   // messages as soon as it is constructed.
  32   ClientImpl(scoped_ptr<Connection> connection,
  33              scoped_ptr<SecureContext> secure_context);
  34   ~ClientImpl() override;
  35
  36   // Client:
  37   void AddObserver(ClientObserver* observer) override;
  38   void RemoveObserver(ClientObserver* observer) override;
  39   bool SupportsSignIn() const override;
  40   void DispatchUnlockEvent() override;
  41   void RequestDecryption(const std::string& challenge) override;
  42   void RequestUnlock() override;
  43
  44  protected:
  45   // Exposed for testing.
  46   Connection* connection() { return connection_.get(); }
  47   SecureContext* secure_context() { return secure_context_.get(); }
  48
  49  private:
  50   // Internal data structure to represent a pending message that either hasn't
  51   // been sent yet or is waiting for a response from the remote device.
  52   struct PendingMessage {
  53     PendingMessage();
  54     PendingMessage(const base::DictionaryValue& message);
  55     ~PendingMessage();
  56
  57     // The message, serialized as JSON.
  58     const std::string json_message;
  59
  60     // The message type. This is possible to parse from the |json_message|; it's
  61     // stored redundantly for convenience.
  62     const std::string type;
  63   };
  64
  65   // Pops the first of the |queued_messages_| and sends it to the remote device.
  66   void ProcessMessageQueue();
  67
  68   // Handles an incoming "status_update" |message|, parsing and notifying
  69   // observers of the content.
  70   void HandleRemoteStatusUpdateMessage(const base::DictionaryValue& message);
  71
  72   // Handles an incoming "decrypt_response" message, parsing and notifying
  73   // observers of the decrypted content.
  74   void HandleDecryptResponseMessage(const base::DictionaryValue& message);
  75
  76   // Handles an incoming "unlock_response" message, notifying observers of the
  77   // response.
  78   void HandleUnlockResponseMessage(const base::DictionaryValue& message);
  79
  80   // ConnectionObserver:
  81   void OnConnectionStatusChanged(Connection* connection,
  82                                  Connection::Status old_status,
  83                                  Connection::Status new_status) override;
  84   void OnMessageReceived(const Connection& connection,
  85                          const WireMessage& wire_message) override;
  86   void OnSendCompleted(const Connection& connection,
  87                        const WireMessage& wire_message,
  88                        bool success) override;
  89
  90   // The connection used to send and receive events and status updates.
  91   scoped_ptr<Connection> connection_;
  92
  93   // Used to encrypt and decrypt payloads sent and received over the
  94   // |connection_|.
  95   scoped_ptr<SecureContext> secure_context_;
  96
  97   // The registered observers of |this_| client.
  98   base::ObserverList<ClientObserver> observers_;
  99
 100   // Queue of messages to send to the remote device.
 101   std::deque<PendingMessage> queued_messages_;
 102
 103   // The current message being sent or waiting on the remote device for a
 104   // response. Null if there is no message currently in this state.
 105   scoped_ptr<PendingMessage> pending_message_;
 106
 107   DISALLOW_COPY_AND_ASSIGN(ClientImpl);
 108 };
 109
 110 }  // namespace proximity_auth
 111
 112 #endif  // COMPONENTS_PROXIMITY_AUTH_CLIENT_IMPL_H