[chrome.displaySource] Add WiFi Display session class skeleton and mojo service

extensions/browser/api/display_source/display_source_connection_delegate.h

 // Copyright 2015 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 EXTENSIONS_BROWSER_API_DISPLAY_SOURCE_DISPLAY_SOURCE_CONNECTION_DELEGATE_H_
 #define EXTENSIONS_BROWSER_API_DISPLAY_SOURCE_DISPLAY_SOURCE_CONNECTION_DELEGATE_H_
 
 #include "base/callback.h"
 #include "base/observer_list.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "extensions/common/api/display_source.h"
 
 namespace extensions {
 
 using DisplaySourceSinkInfoPtr = linked_ptr<api::display_source::SinkInfo>;
 using DisplaySourceSinkInfoList = std::vector<DisplaySourceSinkInfoPtr>;
 using DisplaySourceAuthInfo = api::display_source::AuthenticationInfo;
 
 // The DisplaySourceConnectionDelegate interface should be implemented
 // to provide sinks search and connection functionality for
-// 'chrome.displaySource'
-// API.
+// 'chrome.displaySource' API.
 class DisplaySourceConnectionDelegate : public KeyedService {
  public:
   using AuthInfoCallback = base::Callback<void(const DisplaySourceAuthInfo&)>;
   using FailureCallback = base::Callback<void(const std::string&)>;
   using SinkInfoListCallback =
       base::Callback<void(const DisplaySourceSinkInfoList&)>;
 
+  const static int kInvalidSinkId = -1;
+
   struct Connection {
     Connection();
     ~Connection();
     DisplaySourceSinkInfoPtr connected_sink;
     std::string local_ip;
     std::string sink_ip;
   };
 
   class Observer {
    public:
-    // This method is called each tiome the list of available
+    // This method is called each time the list of available
     // sinks is updated whether after 'GetAvailableSinks' call
-    // or while the implementation is constantly watching the sinks
-    // (after 'StartWatchingSinks' was called).
+    // or while the implementation is constantly watching the
+    // available sinks (after 'StartWatchingAvailableSinks' was called).
+    // Also this method is called to reflect current connection updates.
     virtual void OnSinksUpdated(const DisplaySourceSinkInfoList& sinks) = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   DisplaySourceConnectionDelegate();
   ~DisplaySourceConnectionDelegate() override;
 
   virtual void AddObserver(Observer* observer);
   virtual void RemoveObserver(Observer* observer);
 
   // Returns the list of last found available sinks
   // this list may contain outdated data if the delegate
   // is not watching the sinks (via 'StartWatchingSinks'
   // method). The list is refreshed after 'GetAvailableSinks'
   // call.
   virtual DisplaySourceSinkInfoList last_found_sinks() const = 0;
 
   // Returns the Connection object representing the current
-  // connection to the sink or NULL if there is no curent connection.
+  // connection to the sink or NULL if there is no current connection.
   virtual const Connection* connection() const = 0;
 
   // Queries the list of currently available sinks.
   virtual void GetAvailableSinks(const SinkInfoListCallback& sinks_callback,
                                  const FailureCallback& failure_callback) = 0;
 
   // Queries the authentication method required by the sink for connection.
   // If the used authentication method requires authentication data to be
   // visible on the sink's display (e.g. PIN) the implementation should
   // request the sink to show it.
   virtual void RequestAuthentication(
       int sink_id,
       const AuthInfoCallback& auth_info_callback,
       const FailureCallback& failure_callback) = 0;
 
   // Connects to a sink by given id and auth info.
   virtual void Connect(int sink_id,
                        const DisplaySourceAuthInfo& auth_info,
-                       const base::Closure& connected_callback,
                        const FailureCallback& failure_callback) = 0;
 
   // Disconnects the current connection to sink, the 'failure_callback'
-  // is called if there is no current connection.
-  virtual void Disconnect(const base::Closure& disconnected_callback,
-                          const FailureCallback& failure_callback) = 0;
+  // is called if an error has occurred or if there is no established
+  // connection.
+  virtual void Disconnect(const FailureCallback& failure_callback) = 0;
 
-  // Implementation should start watching the sinks updates.
-  virtual void StartWatchingSinks() = 0;
+  // Implementation should start watching the available sinks updates.
+  virtual void StartWatchingAvailableSinks() = 0;
 
-  // Implementation should stop watching the sinks updates.
-  virtual void StopWatchingSinks() = 0;
+  // Implementation should stop watching the available sinks updates.
+  virtual void StopWatchingAvailableSinks() = 0;
 
  protected:
   base::ObserverList<Observer> observers_;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_DISPLAY_SOURCE_DISPLAY_SOURCE_CONNECTION_DELEGATE_H_