components/proximity_auth/connection.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_CONNECTION_H
   6 #define COMPONENTS_PROXIMITY_AUTH_CONNECTION_H
   7
   8 #include "base/macros.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/observer_list.h"
  12 #include "components/proximity_auth/remote_device.h"
  13
  14 namespace proximity_auth {
  15
  16 class ConnectionObserver;
  17 class WireMessage;
  18
  19 // Base class representing a connection with a remote device, which is a
  20 // persistent bidirectional channel for sending and receiving wire messages.
  21 class Connection {
  22  public:
  23   enum Status {
  24     DISCONNECTED,
  25     IN_PROGRESS,
  26     CONNECTED,
  27   };
  28
  29   // Constructs a connection to the given |remote_device|.
  30   explicit Connection(const RemoteDevice& remote_device);
  31   virtual ~Connection();
  32
  33   // Returns true iff the connection's status is CONNECTED.
  34   bool IsConnected() const;
  35
  36   // Returns true iff the connection is currently sending a message.
  37   bool is_sending_message() const { return is_sending_message_; }
  38
  39   // Sends a message to the remote device.
  40   // |OnSendCompleted()| will be called for all observers upon completion with
  41   // either success or failure.
  42   void SendMessage(scoped_ptr<WireMessage> message);
  43
  44   void AddObserver(ConnectionObserver* observer);
  45   void RemoveObserver(ConnectionObserver* observer);
  46
  47   const RemoteDevice& remote_device() const { return remote_device_; }
  48
  49   // Abstract methods that subclasses should implement:
  50
  51   // Attempts to connect to the remote device if not already connected.
  52   virtual void Connect() = 0;
  53
  54   // Disconnects from the remote device.
  55   virtual void Disconnect() = 0;
  56
  57   Status status() const { return status_; }
  58
  59  protected:
  60   // Sets the connection's status to |status|. If this is different from the
  61   // previous status, notifies observers of the change in status.
  62   // Virtual for testing.
  63   virtual void SetStatus(Status status);
  64
  65   // Called after attempting to send bytes over the connection, whether the
  66   // message was successfully sent or not.
  67   // Virtual for testing.
  68   virtual void OnDidSendMessage(const WireMessage& message, bool success);
  69
  70   // Called when bytes are read from the connection. There should not be a send
  71   // in progress when this function is called.
  72   // Virtual for testing.
  73   virtual void OnBytesReceived(const std::string& bytes);
  74
  75   // Sends bytes over the connection. The implementing class should call
  76   // OnDidSendMessage() once the send succeeds or fails. At most one send will
  77   // be
  78   // in progress.
  79   virtual void SendMessageImpl(scoped_ptr<WireMessage> message) = 0;
  80
  81   // Deserializes the |recieved_bytes_| and returns the resulting WireMessage,
  82   // or NULL if the message is malformed. Sets |is_incomplete_message| to true
  83   // if the |serialized_message| does not have enough data to parse the header,
  84   // or if the message length encoded in the message header exceeds the size of
  85   // the |serialized_message|. Exposed for testing.
  86   virtual scoped_ptr<WireMessage> DeserializeWireMessage(
  87       bool* is_incomplete_message);
  88
  89  private:
  90   // The remote device corresponding to this connection.
  91   const RemoteDevice remote_device_;
  92
  93   // The current status of the connection.
  94   Status status_;
  95
  96   // The registered observers of the connection.
  97   base::ObserverList<ConnectionObserver> observers_;
  98
  99   // A temporary buffer storing bytes received before a received message can be
 100   // fully constructed.
 101   std::string received_bytes_;
 102
 103   // Whether a message is currently in the process of being sent.
 104   bool is_sending_message_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(Connection);
 107 };
 108
 109 }  // namespace proximity_auth
 110
 111 #endif  // COMPONENTS_PROXIMITY_AUTH_CONNECTION_H