Refactors DeviceOrientation to make it more extensible

content/browser/device_orientation/provider_impl.cc

 // Copyright (c) 2012 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 <cmath>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/browser/device_orientation/orientation.h"
 #include "content/browser/device_orientation/provider_impl.h"
 
 namespace device_orientation {
 
 ProviderImpl::ProviderImpl(const DataFetcherFactory factories[])
     : creator_loop_(MessageLoop::current()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   for (const DataFetcherFactory* fp = factories; *fp; ++fp)
     factories_.push_back(*fp);
 }
 
 ProviderImpl::~ProviderImpl() {
 }
 
 void ProviderImpl::AddObserver(Observer* observer) {
   DCHECK(MessageLoop::current() == creator_loop_);
 
   observers_.insert(observer);
   if (observers_.size() == 1)
     Start();
-  else
-    observer->OnOrientationUpdate(last_notification_);
+
+  ScheduleDoAddObserverType(observer->device_data_type());
+
+  if (!data_fetcher_.get()) {
+    ScheduleInitializePollingThread(observer->device_data_type());
+    return;
+  }
+
+  // Notify observer of most recent notification or newly fetched data
+  // if this type of data has not been fetched yet
+  DeviceData* last_notification = last_notifications_map_.Lookup(
+      observer->device_data_type());
+  if (last_notification)
+    observer->OnDeviceDataUpdate(*last_notification);
+  else {
+    scoped_ptr<DeviceData> device_data(EmptyDeviceData(
+        observer->device_data_type()));
+    if (!data_fetcher_->GetDeviceData(device_data.get()) ||
+        device_data->IsEmpty())
+      DoNotify(device_data.release());
+    else
+      observer->OnDeviceDataUpdate(*device_data);
+  }
 }
 
 void ProviderImpl::RemoveObserver(Observer* observer) {
   DCHECK(MessageLoop::current() == creator_loop_);
 
   observers_.erase(observer);
   if (observers_.empty())
     Stop();
 }
 
 void ProviderImpl::Start() {
   DCHECK(MessageLoop::current() == creator_loop_);
   DCHECK(!polling_thread_.get());
 
-  polling_thread_.reset(new base::Thread("Device orientation polling thread"));
+  polling_thread_.reset(new base::Thread("Device data polling thread"));
   if (!polling_thread_->Start()) {
-    LOG(ERROR) << "Failed to start device orientation polling thread";
+    LOG(ERROR) << "Failed to start device data polling thread";
     polling_thread_.reset();
     return;
   }
-  ScheduleInitializePollingThread();
+
+  // reset members used on polling thread
+  last_device_data_map_.reset(new IDMap<DeviceData, IDMapOwnPointer>);
+  observer_types_.clear();
 }
 
 void ProviderImpl::Stop() {
   DCHECK(MessageLoop::current() == creator_loop_);
 
   // TODO(hans): Don't join the thread. See crbug.com/72286.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   polling_thread_.reset();
   data_fetcher_.reset();
 }
 
+void ProviderImpl::DoAddObserverType(
+    DeviceData::DeviceDataType device_data_type) {
+  DCHECK(MessageLoop::current() == polling_thread_->message_loop());
+
+  observer_types_.insert(device_data_type);
+}
+
+void ProviderImpl::ScheduleDoAddObserverType(
+    DeviceData::DeviceDataType device_data_type) {
+  DCHECK(MessageLoop::current() == creator_loop_);
+
+  MessageLoop* polling_loop = polling_thread_->message_loop();
+  polling_loop->PostTask(FROM_HERE,
+                         base::Bind(&ProviderImpl::DoAddObserverType,
+                                    this,
+                                    device_data_type));
+}
+
 void ProviderImpl::DoInitializePollingThread(
-    const std::vector<DataFetcherFactory>& factories) {
+    const std::vector<DataFetcherFactory>& factories,
+    DeviceData::DeviceDataType device_data_type) {
   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 
   typedef std::vector<DataFetcherFactory>::const_iterator Iterator;
   for (Iterator i = factories_.begin(), e = factories_.end(); i != e; ++i) {
     DataFetcherFactory factory = *i;
     scoped_ptr<DataFetcher> fetcher(factory());
-    Orientation orientation;
+    scoped_ptr<DeviceData> device_data(EmptyDeviceData(device_data_type));
 
-    if (fetcher.get() && fetcher->GetOrientation(&orientation)) {
+    if (fetcher.get() && fetcher->GetDeviceData(device_data.get())) {
       // Pass ownership of fetcher to provider_.
       data_fetcher_.swap(fetcher);
-      last_orientation_ = orientation;
+      last_device_data_map_->AddWithID(device_data->Clone(), device_data_type);
 
       // Notify observers.
-      if (!orientation.is_empty())
-        ScheduleDoNotify(orientation);
+      if (!device_data->IsEmpty())
+        ScheduleDoNotify(device_data.release());
 
       // Start polling.
       ScheduleDoPoll();
       return;
     }
   }
 
-  // When no orientation data can be provided.
-  ScheduleDoNotify(Orientation::Empty());
+  // When no device data can be provided.
+  ScheduleDoNotify(EmptyDeviceData(device_data_type));
 }
 
-void ProviderImpl::ScheduleInitializePollingThread() {
+void ProviderImpl::ScheduleInitializePollingThread(
+    DeviceData::DeviceDataType device_data_type) {
   DCHECK(MessageLoop::current() == creator_loop_);
 
   MessageLoop* polling_loop = polling_thread_->message_loop();
   polling_loop->PostTask(FROM_HERE,
                          base::Bind(&ProviderImpl::DoInitializePollingThread,
                                     this,
-                                    factories_));
+                                    factories_,
+                                    device_data_type));
 }
 
-void ProviderImpl::DoNotify(const Orientation& orientation) {
+void ProviderImpl::DoNotify(const DeviceData* device_data) {
   DCHECK(MessageLoop::current() == creator_loop_);
 
-  last_notification_ = orientation;
+  scoped_ptr<const DeviceData> data(device_data);
+  DeviceData::DeviceDataType device_data_type = data->device_data_type();
 
-  typedef std::set<Observer*>::const_iterator Iterator;
-  for (Iterator i = observers_.begin(), e = observers_.end(); i != e; ++i)
-    (*i)->OnOrientationUpdate(orientation);
+  // update last notification of this type
+  DeviceData* last_notification = last_notifications_map_.Lookup(
+      device_data_type);
+  if (last_notification)
+    last_notifications_map_.Remove(device_data_type);
+  last_notifications_map_.AddWithID(data->Clone(), device_data_type);
 
-  if (orientation.is_empty()) {
-    // Notify observers about failure to provide data exactly once.
-    observers_.clear();
-    Stop();
+  // notify observers of this type of the new data
+  typedef std::set<Observer*>::const_iterator ConstIterator;
+  for (ConstIterator i = observers_.begin(), e = observers_.end();
+       i != e; ++i) {
+    if ((*i)->device_data_type() == device_data_type)
+      (*i)->OnDeviceDataUpdate(*data);
+  }
+
+  if (device_data->IsEmpty()) {
+    // Notify observers about failure to provide data exactly once
+    typedef std::set<Observer*>::iterator Iterator;
+    Iterator i = observers_.begin();
+    while (i != observers_.end()) {
+      Iterator current = i++;
+      if ((*current)->device_data_type() == device_data_type)
+        observers_.erase(current);
+    }
+
+    if (observers_.empty())
+      Stop();
   }
 }
 
-void ProviderImpl::ScheduleDoNotify(const Orientation& orientation) {
+void ProviderImpl::ScheduleDoNotify(const DeviceData* device_data) {
   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 
-  creator_loop_->PostTask(
-      FROM_HERE, base::Bind(&ProviderImpl::DoNotify, this, orientation));
+  creator_loop_->PostTask(FROM_HERE,
+                          base::Bind(&ProviderImpl::DoNotify, this,
+                                     device_data));
 }
 
 void ProviderImpl::DoPoll() {
   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 
-  Orientation orientation;
-  if (!data_fetcher_->GetOrientation(&orientation)) {
-    LOG(ERROR) << "Failed to poll device orientation data fetcher.";
+  // Poll the fetcher for each type of data
+  typedef std::set<DeviceData::DeviceDataType>::const_iterator SetIterator;
+  for (SetIterator i = observer_types_.begin(), e = observer_types_.end();
+       i != e; ++i) {
+    DeviceData::DeviceDataType device_data_type = *i;
+    scoped_ptr<DeviceData> device_data(EmptyDeviceData(device_data_type));
 
-    ScheduleDoNotify(Orientation::Empty());
-    return;
-  }
+    if (!data_fetcher_->GetDeviceData(device_data.get())) {
+      LOG(ERROR) << "Failed to poll device data fetcher.";
 
-  if (!orientation.is_empty() &&
-      SignificantlyDifferent(orientation, last_orientation_)) {
-    last_orientation_ = orientation;
-    ScheduleDoNotify(orientation);
+      ScheduleDoNotify(EmptyDeviceData(device_data_type));
+      return;
+    }
+
+    // Update the last device data of this type and notify observers
+    DeviceData* last_device_data = last_device_data_map_->Lookup(
+        device_data_type);
+    if (!last_device_data) {
+      last_device_data_map_->AddWithID(device_data->Clone(), device_data_type);
+      ScheduleDoNotify(device_data.release());
+    }
+    else if (device_data->SignificantlyDifferentFrom(*last_device_data)) {
+      last_device_data_map_->Remove(device_data_type);
+      last_device_data_map_->AddWithID(device_data->Clone(), device_data_type);
+      ScheduleDoNotify(device_data.release());
+    }
   }
 
   ScheduleDoPoll();
 }
 
 void ProviderImpl::ScheduleDoPoll() {
   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 
   MessageLoop* polling_loop = polling_thread_->message_loop();
   polling_loop->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ProviderImpl::DoPoll, weak_factory_.GetWeakPtr()),
       SamplingInterval());
 }
 
-namespace {
-
-bool IsElementSignificantlyDifferent(bool can_provide_element1,
-                                     bool can_provide_element2,
-                                     double element1,
-                                     double element2) {
-  const double kThreshold = 0.1;
-
-  if (can_provide_element1 != can_provide_element2)
-    return true;
-  if (can_provide_element1 &&
-      std::fabs(element1 - element2) >= kThreshold)
-    return true;
-  return false;
-}
-}  // namespace
-
-// Returns true if two orientations are considered different enough that
-// observers should be notified of the new orientation.
-bool ProviderImpl::SignificantlyDifferent(const Orientation& o1,
-                                          const Orientation& o2) {
-  return IsElementSignificantlyDifferent(o1.can_provide_alpha(),
-                                         o2.can_provide_alpha(),
-                                         o1.alpha(),
-                                         o2.alpha()) ||
-         IsElementSignificantlyDifferent(o1.can_provide_beta(),
-                                         o2.can_provide_beta(),
-                                         o1.beta(),
-                                         o2.beta()) ||
-         IsElementSignificantlyDifferent(o1.can_provide_gamma(),
-                                         o2.can_provide_gamma(),
-                                         o1.gamma(),
-                                         o2.gamma()) ||
-         (o1.can_provide_absolute() != o2.can_provide_absolute() ||
-          o1.absolute() != o2.absolute());
-}
-
 base::TimeDelta ProviderImpl::SamplingInterval() const {
   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
   DCHECK(data_fetcher_.get());
 
   // TODO(erg): There used to be unused code here, that called a default
   // implementation on the DataFetcherInterface that was never defined. I'm
   // removing unused methods from headers.
   return base::TimeDelta::FromMilliseconds(kDesiredSamplingIntervalMs);
 }
 
+DeviceData* ProviderImpl::EmptyDeviceData(DeviceData::DeviceDataType type) {
+  if (type == DeviceData::kDeviceOrientationData)
+    return new Orientation();
+  else
+    return NULL;
+}
+
 }  // namespace device_orientation