Load CMA backend from shared library

chromecast/media/cma/backend/media_clock_device_default.cc

Index: chromecast/media/cma/backend/media_clock_device_default.cc
diff --git a/chromecast/media/cma/backend/media_clock_device_default.cc b/chromecast/media/cma/backend/media_clock_device_default.cc
index 086083dda3f3721b6726af4aa41d7805a552ad7b..0855cf32e7a919e6c4427399068628a56263bc44 100644
--- a/chromecast/media/cma/backend/media_clock_device_default.cc
+++ b/chromecast/media/cma/backend/media_clock_device_default.cc
@@ -8,25 +8,53 @@
 
 namespace chromecast {
 namespace media {
+namespace {
+
+// Return true if transition from |state1| to |state2| is a valid state
+// transition.
+inline static bool IsValidStateTransition(MediaClockDevice::State state1,
+                                          MediaClockDevice::State state2) {
+  if (state2 == state1)
+    return true;
+
+  // All states can transition to |kStateError|.
+  if (state2 == MediaClockDevice::kStateError)
+    return true;
+
+  // All the other valid FSM transitions.
+  switch (state1) {
+    case MediaClockDevice::kStateUninitialized:
+      return state2 == MediaClockDevice::kStateIdle;
+    case MediaClockDevice::kStateIdle:
+      return state2 == MediaClockDevice::kStateRunning ||
+             state2 == MediaClockDevice::kStateUninitialized;
+    case MediaClockDevice::kStateRunning:
+      return state2 == MediaClockDevice::kStateIdle;
+    case MediaClockDevice::kStateError:
+      return state2 == MediaClockDevice::kStateUninitialized;
+    default:
+      return false;
+  }
+}
+
+}  // namespace
 
 MediaClockDeviceDefault::MediaClockDeviceDefault()
-    : state_(kStateUninitialized),
-      media_time_(::media::kNoTimestamp()) {
-  DetachFromThread();
+    : state_(kStateUninitialized), media_time_(::media::kNoTimestamp()) {
+  thread_checker_.DetachFromThread();
 }
 
 MediaClockDeviceDefault::~MediaClockDeviceDefault() {
 }
 
 MediaClockDevice::State MediaClockDeviceDefault::GetState() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   return state_;
 }
 
 bool MediaClockDeviceDefault::SetState(State new_state) {
-  DCHECK(CalledOnValidThread());
-  if (!MediaClockDevice::IsValidStateTransition(state_, new_state))
-    return false;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(IsValidStateTransition(state_, new_state));
 
   if (new_state == state_)
     return true;
@@ -47,15 +75,15 @@ bool MediaClockDeviceDefault::SetState(State new_state) {
   return true;
 }
 
-bool MediaClockDeviceDefault::ResetTimeline(base::TimeDelta time) {
-  DCHECK(CalledOnValidThread());
+bool MediaClockDeviceDefault::ResetTimeline(int64_t time_microseconds) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kStateIdle);
-  media_time_ = time;
+  media_time_ = base::TimeDelta::FromMicroseconds(time_microseconds);
   return true;
 }
 
 bool MediaClockDeviceDefault::SetRate(float rate) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ == kStateRunning) {
     base::TimeTicks now = base::TimeTicks::Now();
     media_time_ = media_time_ + (now - stc_) * rate_;
@@ -66,18 +94,18 @@ bool MediaClockDeviceDefault::SetRate(float rate) {
   return true;
 }
 
-base::TimeDelta MediaClockDeviceDefault::GetTime() {
-  DCHECK(CalledOnValidThread());
+int64_t MediaClockDeviceDefault::GetTimeMicroseconds() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kStateRunning)
-    return media_time_;
+    return media_time_.InMicroseconds();
 
   if (media_time_ == ::media::kNoTimestamp())
-    return ::media::kNoTimestamp();
+    return media_time_.InMicroseconds();
 
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeDelta interpolated_media_time =
       media_time_ + (now - stc_) * rate_;
-  return interpolated_media_time;
+  return interpolated_media_time.InMicroseconds();
 }
 
 }  // namespace media