Add polling and audio check to copresence.

components/copresence/handlers/directive_handler.h

 // Copyright 2014 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 COMPONENTS_COPRESENCE_HANDLERS_DIRECTIVE_HANDLER_H_
 #define COMPONENTS_COPRESENCE_HANDLERS_DIRECTIVE_HANDLER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "components/copresence/public/whispernet_client.h"
+#include "components/copresence/public/copresence_constants.h"
 
 namespace copresence {
 
 class AudioDirectiveHandler;
 class Directive;
+class WhispernetClient;
 
 // The directive handler manages transmit and receive directives.
 // TODO(ckehoe): Add tests for this class.
 // TODO(ckehoe): Turn this into an interface.
 class DirectiveHandler {
  public:
   DirectiveHandler();
   virtual ~DirectiveHandler();
 
   // Starts processing directives with the provided Whispernet client.
   // Directives will be queued until this function is called.
-  // |whispernet_client| is owned by the caller
-  // and must outlive the DirectiveHandler.
-  virtual void Start(WhispernetClient* whispernet_client);
+  // |whispernet_client| is owned by the caller and must outlive the
+  // DirectiveHandler.
+  // |tokens_cb| is called for all audio tokens found in recorded audio.
+  virtual void Start(WhispernetClient* whispernet_client,
+                     const TokensCallback& tokens_cb);
 
   // Adds a directive to handle.
   virtual void AddDirective(const Directive& directive);
 
   // Removes any directives associated with the given operation id.
   virtual void RemoveDirectives(const std::string& op_id);
 
+  // TODO(rkc): Too many audio specific functions here, find a better way to

[Charlie, 2014/11/06 17:28:23]

CopresenceManagerImpl::CheckForAudio() probably belongs in the AudioManager. No
time to fix it in this CL though.

[rkc, 2014/11/06 19:58:24]

It doesn't solve the problem. If we put it in the audio manager, we'd need to
plumb down a callback to report errors; so the net result will be the same. We
have too much coupling between the audio manager (a component several levels
down the chain) and the copresence manager.

[Charlie, 2014/11/06 21:53:14]

I don't actually think the AudioManager should be buried like this. Objects that
are hidden inside others should be there because they're an implementation
detail, like the vectors we use to store queues. But it's turning out that the
AudioManager is more than an implementation detail of directives. So it probably
belongs under CopresenceManager directly.

[rkc, 2014/11/06 21:58:34]

We can discuss this offline if you wish. I think the directive handler should
abstract its individual discovery medium handlers - of course, this is not
happening too well.

+  // get this information to the copresence manager.
   virtual const std::string GetCurrentAudioToken(AudioType type) const;
+  virtual bool IsAudioTokenHeard(AudioType type) const;
 
  private:
   // Starts actually running a directive.
   void StartDirective(const std::string& op_id, const Directive& directive);
 
-  // Forwards the request to encode a token to whispernet,
-  // and instructs it to call samples_callback when encoding is complete.
-  void EncodeToken(
-      const std::string& token,
-      AudioType type,
-      const WhispernetClient::SamplesCallback& samples_callback);
-
   scoped_ptr<AudioDirectiveHandler> audio_handler_;
   std::map<std::string, std::vector<Directive>> pending_directives_;
 
-  // Belongs to the caller.
-  WhispernetClient* whispernet_client_;
+  bool is_started_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectiveHandler);
 };
 
 }  // namespace copresence
 
 #endif  // COMPONENTS_COPRESENCE_HANDLERS_DIRECTIVE_HANDLER_H_