Implement Android shared memory data fetcher for Device Motion.

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 "content/browser/device_orientation/provider_impl.h"
 
 #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/worker_pool.h"
 
+#if defined(OS_ANDROID)
+#include "content/browser/device_orientation/data_fetcher_impl_android.h"
+#elif defined(OS_WIN)
+#include "content/browser/device_orientation/data_fetcher_impl_win.h"
+#endif
+
 namespace {
 
 void DeleteThread(base::Thread* thread) {
   delete thread;
 }
 
 }
 
 namespace content {
 
@@ skipping 21 matching lines @@
   void ScheduleDoNotify(const scoped_refptr<const DeviceData>& device_data,
                         DeviceData::Type device_data_type);
 
   enum { kDesiredSamplingIntervalMs = 100 };
   base::TimeDelta SamplingInterval() const;
 
   // The Message Loop on which this object was created.
   // Typically the I/O loop, but may be something else during testing.
   base::MessageLoop* creator_loop_;
 
-  scoped_ptr<DataFetcher> data_fetcher_;
+  DataFetcher* data_fetcher_;
+
   std::map<DeviceData::Type, scoped_refptr<const DeviceData> >
     last_device_data_map_;
   std::set<DeviceData::Type> polling_data_types_;
 
   base::WeakPtr<ProviderImpl> provider_;
 };
 
 ProviderImpl::PollingThread::PollingThread(const char* name,
                                            base::WeakPtr<ProviderImpl> provider,
                                            base::MessageLoop* creator_loop)
     : base::Thread(name), creator_loop_(creator_loop), provider_(provider) {}
 
 ProviderImpl::PollingThread::~PollingThread() {
+#if defined(OS_ANDROID)

[bulach, 2013/07/10 16:59:41]

// TODO(timvolodine): Remove this platform dependency once
// orientation also switches to shared memory implementation.

[timvolodine, 2013/07/11 14:31:34]

N/A anymore.
Done.

+  static_cast<DataFetcherImplAndroid*>(data_fetcher_)->Stop(
+      DeviceData::kTypeOrientation);
+#elif defined(OS_WIN)
+  static_cast<DataFetcherImplWin*>(data_fetcher_)->Stop();
+#endif
   Stop();
 }
 
 void ProviderImpl::PollingThread::DoAddPollingDataType(DeviceData::Type type) {
   DCHECK(base::MessageLoop::current() == message_loop());
 
   polling_data_types_.insert(type);
 }
 
 void ProviderImpl::PollingThread::Initialize(DataFetcherFactory factory,
                                              DeviceData::Type type) {
   DCHECK(base::MessageLoop::current() == message_loop());
 
   if (factory != NULL) {
     // Try to use factory to create a fetcher that can provide this type of
     // data. If factory creates a fetcher that provides this type of data,
     // start polling.
-    scoped_ptr<DataFetcher> fetcher(factory());
+    DataFetcher* fetcher = factory();

[bulach, 2013/07/10 16:59:41]

hmm... factory() normally means it'll create an object, and the caller takes
ownership.. in this case, it'd be better as something like
GetFetcherInstance()... all Fetchers would have to change, since their "Create"
methods and this factory don't make much sense anymore...

however, thinking more about this:
it seems we're completely changing the ownership model of the fetcher.
it'd probably be better to do all of that in a separate patch, then this one can
focus only on implementing the Android data fetcher... wdyt?

[timvolodine, 2013/07/11 14:31:34]

Sure. I've refactored the code and added a new class for handling the device
orientation implementation in a transparent way, as discussed yesterday. The
other fetchers and the device orientation provider do not have to change in this
case.

 
     if (fetcher) {
       scoped_refptr<const DeviceData> device_data(fetcher->GetDeviceData(type));
       if (device_data.get() != NULL) {
         // Pass ownership of fetcher to provider_.

[bulach, 2013/07/10 16:59:41]

remove comment?

[timvolodine, 2013/07/11 14:31:34]

N/A anymore.
Done.

-        data_fetcher_.swap(fetcher);
+        data_fetcher_ = fetcher;
         last_device_data_map_[type] = device_data;
 
         // Notify observers.
         ScheduleDoNotify(device_data, type);
 
         // Start polling.
         ScheduleDoPoll();
         return;
       }
     }
@@ skipping 46 matching lines @@
   DCHECK(base::MessageLoop::current() == message_loop());
 
   message_loop()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&PollingThread::DoPoll, base::Unretained(this)),
       SamplingInterval());
 }
 
 base::TimeDelta ProviderImpl::PollingThread::SamplingInterval() const {
   DCHECK(base::MessageLoop::current() == message_loop());
-  DCHECK(data_fetcher_.get());
+  DCHECK(data_fetcher_);
 
   // 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);
 }
 
 ProviderImpl::ProviderImpl(DataFetcherFactory factory)
     : creator_loop_(base::MessageLoop::current()),
       factory_(factory),
@@ skipping 111 matching lines @@
         observers_.erase(current);
     }
 
     if (observers_.empty())
       Stop();
   }
 }
 
 
 }  // namespace content