Load CMA backend from shared library

chromecast/public/media/media_clock_device.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 CHROMECAST_MEDIA_CMA_BACKEND_MEDIA_CLOCK_DEVICE_H_
-#define CHROMECAST_MEDIA_CMA_BACKEND_MEDIA_CLOCK_DEVICE_H_
+#ifndef CHROMECAST_PUBLIC_MEDIA_MEDIA_CLOCK_DEVICE_H_
+#define CHROMECAST_PUBLIC_MEDIA_MEDIA_CLOCK_DEVICE_H_
 
 #include <string>
 
-#include "base/basictypes.h"
-#include "base/macros.h"
-#include "base/threading/non_thread_safe.h"
-#include "base/time/time.h"
+#include "chromecast/public/time_delta.h"

[byungchul, 2015/07/27 18:22:23]

relative to chromecast/public

[halliwell, 2015/07/28 02:19:36]

TimeDelta removed now anyway.

 
 namespace chromecast {
 namespace media {
 
 // MediaClockDevice -
 //
 // State machine:
 //                      -------------------
 //                      |                 |
 //                      v                 |
 // kUninitialized --> kIdle  --------- kRunning
 //
 // {any state} --> kError
 //
 // Notes:
 // - Hardware resources are acquired when transitioning from the
 //   |kUninitialized| state to the |kIdle| state.
 // - The initial value of the timeline can only be set in the kIdle state.
 //
-class MediaClockDevice
-    : NON_EXPORTED_BASE(public base::NonThreadSafe) {
+class MediaClockDevice {
  public:
   enum State {
     kStateUninitialized,
     kStateIdle,
     kStateRunning,
     kStateError,
   };
 
   // Return true if transition from |state1| to |state2| is a valid state
   // transition.
-  static bool IsValidStateTransition(State state1, State state2);
+  inline static bool IsValidStateTransition(State state1, State state2) {
+    if (state2 == state1)
+      return true;
+
+    // All states can transition to |kStateError|.
+    bool is_transition_valid = (state2 == kStateError);
+
+    // All the other valid FSM transitions.
+    is_transition_valid =
+        is_transition_valid ||
+        (state1 == kStateUninitialized && (state2 == kStateIdle)) ||
+        (state1 == kStateIdle &&
+         (state2 == kStateRunning || state2 == kStateUninitialized)) ||
+        (state1 == kStateRunning && (state2 == kStateIdle)) ||
+        (state1 == kStateError && (state2 == kStateUninitialized));
+
+    return is_transition_valid;
+  }
 
   // Returns string representation of state (for logging)
-  static std::string StateToString(const State& state);
+  inline static std::string StateToString(const State& state) {
+    switch (state) {
+      case kStateUninitialized:
+        return "Uninitialized";
+      case kStateIdle:
+        return "Idle";
+      case kStateRunning:
+        return "Running";
+      case kStateError:
+        return "Error";
+      default:
+        return "";
+    }
+  }

[byungchul, 2015/07/27 18:22:23]

Why are these 2 files defined here inline? Is it allowed for chromium? Are they
really necessary for shlibs?

[halliwell, 2015/07/28 02:19:36]

Yes, it's allowed.  And all vendors call these functions.  Easiest way was to
just inline them for now.

[byungchul, 2015/07/28 18:05:43]

I think
1) StateToString() is not necessary to be in public apis. It should be in each
implementations.
3) Who changes state?
3) how can we force vendors to call IsValidStateTransition() whenever state is
changed? Why is it correct? For example, the state cannot be changed from
uninitialized to running, but it can be changed uninitialized -> idle ->
running. If the caller missed the change of uninitialized -> idle, it is same to
the change of uinitialized -> running.

[halliwell, 2015/07/28 23:26:06]

StateToString now moved out into implementation code.

I moved IsValidStateTransition into backends, also used it for an assertion in
the default implementation, I don't think we should allow invalid state
transitions as something vendors are expected to support.

I think the state machine is still awkward for vendors to implement, lcwu would
like us to look at simplifying the interface later on, but not for this release.

 
-  MediaClockDevice();
-  virtual ~MediaClockDevice();
+  MediaClockDevice() {}
+  virtual ~MediaClockDevice() {}
 
   // Return the current state of the media clock.
   virtual State GetState() const = 0;
 
   // Changes the state and performs any necessary transitions.
   // Returns true when successful.
   virtual bool SetState(State new_state) = 0;
 
   // Sets the initial value of the timeline.
   // Can only be invoked in state kStateIdle.
   // Returns true when successful.
-  virtual bool ResetTimeline(base::TimeDelta time) = 0;
+  virtual bool ResetTimeline(TimeDelta time) = 0;
 
   // Sets the clock rate.
   // Setting it to 0 means the clock is not progressing and that the renderer
   // tied to this media clock should pause rendering.
   // Can only be invoked in states kStateIdle or kStateRunning.
   virtual bool SetRate(float rate) = 0;
 
   // Retrieves the media clock time.
   // Can only be invoked in states kStateIdle or kStateRunning.
-  virtual base::TimeDelta GetTime() = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MediaClockDevice);
+  virtual TimeDelta GetTime() = 0;
 };
 
 }  // namespace media
 }  // namespace chromecast
 
 #endif  // CHROMECAST_MEDIA_CMA_BACKEND_MEDIA_CLOCK_DEVICE_H_