Moving the DirectiveHandler to be owned by CopresenceManager.

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/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "components/copresence/handlers/audio/audio_directive_handler.h"
-#include "components/copresence/mediums/audio/audio_manager.h"
+#include "components/copresence/public/whispernet_client.h"
 
 namespace copresence {
 
+class AudioDirectiveHandler;
 class Directive;
 
-// The directive handler manages transmit and receive directives
-// given to it by the manager.
+// The directive handler manages transmit and receive directives.
+// TODO(ckehoe): Add tests for this class.

[rkc, 2014/10/31 17:18:06]

This class is now complex enough that this shouldn't just be a TODO. I'd feel a
lot more comfortable if we checked this in with at least a few basic tests.

[Charlie, 2014/10/31 17:47:06]

I agree, but there's some refactoring required to allow a fake
AudioDirectiveHandler to be injected properly. So I was going to do that plus
the tests in a separate CL. Instead, I'll do just the refactoring separately,
and add the tests here once I sync.

[rkc, 2014/10/31 18:06:15]

That's fine, you can do them both in another CL. As long as they get done right
after this CL and not Soon(TM). :)

[Charlie, 2014/10/31 18:20:55]

The CL is in progress already. And you know how much I like refactoring :-)

+// TODO(ckehoe): Turn this into an interface.
 class DirectiveHandler {
  public:
   DirectiveHandler();
   virtual ~DirectiveHandler();
 
-  // Initialize the |audio_handler_| with the appropriate callbacks.
-  // This function must be called before any others.
-  // TODO(ckehoe): Instead of this, use a static Create() method
-  //               and make the constructor private.
-  virtual void Initialize(const AudioManager::DecodeSamplesCallback& decode_cb,
-                          const AudioManager::EncodeTokenCallback& encode_cb);
+  // 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);
 
   // Adds a directive to handle.
-  virtual void AddDirective(const copresence::Directive& directive);
+  virtual void AddDirective(const Directive& directive);
+
   // Removes any directives associated with the given operation id.
   virtual void RemoveDirectives(const std::string& op_id);
 
-  const std::string GetCurrentAudioToken(AudioType type) const;
+  virtual const std::string GetCurrentAudioToken(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_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectiveHandler);
 };
 
 }  // namespace copresence
 
 #endif  // COMPONENTS_COPRESENCE_HANDLERS_DIRECTIVE_HANDLER_H_