Adds metronome time sync dbus client

chromeos/dbus/metronome_client.cc

+// Copyright 2015 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.
+
+#include "chromeos/dbus/metronome_client.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+#include "dbus/bus.h"
+#include "dbus/message.h"
+#include "dbus/object_path.h"
+#include "dbus/object_proxy.h"
+
+// TODO(benchan): Move these DBus constants to system_api.
+namespace metronome {
+
+const char kMetronomeInterface[] = "org.chromium.Metronome";
+const char kMetronomeServiceName[] = "org.chromium.Metronome";
+const char kMetronomeServicePath[] = "/org/chromium/Metronome";
+const char kTimestampUpdatedSignal[] = "TimestampUpdated";
+
+}  // namespace metronome
+
+namespace chromeos {
+
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// The MetronomeClient implementation.
+class MetronomeClientImpl : public MetronomeClient {
+ public:
+  MetronomeClientImpl() : proxy_(NULL), once_(false), weak_ptr_factory_(this) {}
+
+  ~MetronomeClientImpl() override {}
+
+  // MetronomeClient:
+  void AddObserver(Observer* observer) override;
+  void RemoveObserver(Observer* observer) override;
+
+ protected:
+  void Init(dbus::Bus* bus) override;
+
+ private:
+  // Handles TimestampUpdated signal and notifies |observers_|.
+  void OnTimestampUpdated(dbus::Signal* signal);
+
+  // Handles the result of signal connection setup.
+  void OnSignalConnected(const std::string& interface,
+                         const std::string& signal,
+                         bool succeeded);
+
+  dbus::ObjectProxy* proxy_;
+
+  // True when |proxy_| has been connected.
+  bool once_;

[stevenjb, 2015/02/24 23:42:54]

nit: Use a more descriptive variable name, e.g. signal_connected_

[varkha, 2015/02/25 01:08:47]

Done.

+
+  // List of observers interested in event notifications from us.
+  ObserverList<Observer> observers_;
+
+  // Note: This should remain the last member so it'll be destroyed and
+  // invalidate its weak pointers before any other members are destroyed.
+  base::WeakPtrFactory<MetronomeClientImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(MetronomeClientImpl);
+};
+
+void MetronomeClientImpl::AddObserver(Observer* observer) {
+  DCHECK(observer);
+  if (!once_) {
+    once_ = true;
+    proxy_->ConnectToSignal(metronome::kMetronomeInterface,
+                            metronome::kTimestampUpdatedSignal,
+                            base::Bind(&MetronomeClientImpl::OnTimestampUpdated,
+                                       weak_ptr_factory_.GetWeakPtr()),
+                            base::Bind(&MetronomeClientImpl::OnSignalConnected,
+                                       weak_ptr_factory_.GetWeakPtr()));
+  }
+  observers_.AddObserver(observer);
+}
+
+void MetronomeClientImpl::RemoveObserver(Observer* observer) {
+  DCHECK(observer);
+  observers_.RemoveObserver(observer);
+}
+
+void MetronomeClientImpl::Init(dbus::Bus* bus) {
+  proxy_ =
+      bus->GetObjectProxy(metronome::kMetronomeServiceName,
+                          dbus::ObjectPath(metronome::kMetronomeServicePath));
+}
+
+void MetronomeClientImpl::OnTimestampUpdated(dbus::Signal* signal) {
+  dbus::MessageReader reader(signal);
+  uint64 beacon_timestamp = 0;
+  uint64 local_timestamp = 0;
+  if (!reader.PopUint64(&beacon_timestamp) ||
+      !reader.PopUint64(&local_timestamp)) {
+    LOG(ERROR) << "Invalid signal: " << signal->ToString();
+    return;
+  }
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnTimestampUpdated(beacon_timestamp, local_timestamp));
+}
+
+void MetronomeClientImpl::OnSignalConnected(const std::string& interface,
+                                            const std::string& signal,
+                                            bool succeeded) {
+  LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " " << signal
+                            << " failed.";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// A stub implementation of MetronomeClient. It does not provide true
+// synchronization and only exists to exercise the interfaces.
+class MetronomeClientStubImpl : public MetronomeClient {
+ public:
+  MetronomeClientStubImpl() : timer_(true, true), weak_ptr_factory_(this) {}
+
+  ~MetronomeClientStubImpl() override { timer_.Stop(); }
+
+  // MetronomeClient overrides:
+  void Init(dbus::Bus* bus) override {
+    timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(1000),
+                 base::Bind(&MetronomeClientStubImpl::OnTimer,
+                            weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  void AddObserver(Observer* observer) override {
+    DCHECK(observer);
+    observers_.AddObserver(observer);
+  }
+
+  void RemoveObserver(Observer* observer) override {
+    DCHECK(observer);
+    observers_.RemoveObserver(observer);
+  }
+
+  void OnTimer() {
+    base::Time now_time = base::Time::Now();
+    base::TimeTicks now_ticks = base::TimeTicks::Now();
+    uint64 fake_beacon_timestamp = now_time.ToInternalValue();
+    uint64 fake_local_timestamp = now_ticks.ToInternalValue();
+    FOR_EACH_OBSERVER(
+        Observer, observers_,
+        OnTimestampUpdated(fake_beacon_timestamp, fake_local_timestamp));
+  }
+
+ private:
+  base::Timer timer_;
+  // List of observers interested in event notifications from us.
+  ObserverList<Observer> observers_;
+
+  // Note: This should remain the last member so it'll be destroyed and
+  // invalidate its weak pointers before any other members are destroyed.
+  base::WeakPtrFactory<MetronomeClientStubImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(MetronomeClientStubImpl);
+};
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+
+MetronomeClient::MetronomeClient() {
+}
+
+MetronomeClient::~MetronomeClient() {
+}
+
+// static
+MetronomeClient* MetronomeClient::Create(DBusClientImplementationType type) {
+  if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
+    return new MetronomeClientImpl();
+
+  DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
+  return new MetronomeClientStubImpl();
+}
+
+}  // namespace chromeos