Redesign the copresence audio handlers.

components/copresence/handlers/audio/audio_directive_list.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_AUDIO_AUDIO_DIRECTIVE_LIST_H_
 #define COMPONENTS_COPRESENCE_HANDLERS_AUDIO_AUDIO_DIRECTIVE_LIST_H_
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 
+namespace base {
+class TickClock;
+}
+
 namespace media {
 class AudioBusRefCounted;
 }
 
 namespace copresence {
 
-struct AudioDirective {
+struct AudioDirective final {

[Daniel Erat, 2014/10/22 16:34:35]

nit: putting final on a struct seems unnecessary

[rkc, 2014/10/22 18:21:47]

Done.

   // Default ctor, required by the priority queue.
   AudioDirective();
-  AudioDirective(const std::string& op_id, base::Time end_time);
+  AudioDirective(const std::string& op_id, base::TimeTicks end_time);
 
   std::string op_id;
-  base::Time end_time;
+  base::TimeTicks end_time;

[Daniel Erat, 2014/10/22 16:34:35]

while i pretty much always support the use of TimeTicks rather than Time, just
want to make sure: one difference (at least on cros) is that TimeTicks won't
advance while the system is suspended. probably doesn't matter here, but wanted
to make sure you were aware of it.

[rkc, 2014/10/22 18:21:47]

I read that in the documentation but don't think it effects this code. If
NowTicks will always return the number of ticks since epoch, whether a system
was suspended or not shoudln't make a difference, correct?

[Daniel Erat, 2014/10/22 18:32:40]

i'm not aware of anything that returns ticks since the epoch -- is TimeTicks
documented as representing that somewhere? at least on linux, i'm pretty sure
it's nanoseconds since boot minus any intervals where the system was suspended.

the main concern with using TimeTicks here would just be that you could end up
with stale directives if e.g. the system suspended for a long time. base::Time
has its own problems, in that it'll get messed up if the user (or an NTP daemon)
changes the system clock.

[rkc, 2014/10/22 19:28:46]

So the posix implementation of Time::Now() returns time since Windows epoch.
This is really strange though, the Windows implementation of Time::Now() returns
TimeTicks::Now(), and I have no clue what mac is even doing.

Considering that TimeTicks seem to be based on the high resolution timer and are
guaranteed not to go backwards, I'll leave this as TimeTicks for now. Creating a
bug for this and linked it here to investigate this further to figure out what
time we really need to use; and what code needs to be written to compensate for
system suspends.

 };
 
 // This class maintains a list of active audio directives. It fetches the audio
 // samples associated with a audio transmit directives and expires directives
 // that have outlived their TTL.
 // TODO(rkc): Once we implement more token technologies, move reusable code
 // from here to a base class and inherit various XxxxDirectiveList
 // classes from it.
 class AudioDirectiveList {
  public:
   AudioDirectiveList();
-  virtual ~AudioDirectiveList();
+  ~AudioDirectiveList();
 
   void AddDirective(const std::string& op_id, base::TimeDelta ttl);
   void RemoveDirective(const std::string& op_id);
 
   scoped_ptr<AudioDirective> GetActiveDirective();
 
  private:
   // Comparator for comparing end_times on audio tokens.
   class LatestFirstComparator {
    public:
     // This will sort our queue with the 'latest' time being the top.
     bool operator()(const AudioDirective& left,
                     const AudioDirective& right) const {
       return left.end_time < right.end_time;
     }
   };
 
   std::vector<AudioDirective>::iterator FindDirectiveByOpId(
       const std::string& op_id);
 
   // This vector will be organized as a heap with the latest time as the first
   // element. Only currently active directives will exist in this list.
   std::vector<AudioDirective> active_directives_;
 
+  scoped_ptr<base::TickClock> clock_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioDirectiveList);
 };
 
 }  // namespace copresence
 
 #endif  // COMPONENTS_COPRESENCE_HANDLERS_AUDIO_AUDIO_DIRECTIVE_LIST_H_