Gamepad API support for chrome on android

content/browser/gamepad/gamepad_provider.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2014, NVIDIA CORPORATION. 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/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
+#include "base/time/time.h"
 #include "content/browser/gamepad/gamepad_data_fetcher.h"
 #include "content/browser/gamepad/gamepad_platform_data_fetcher.h"
 #include "content/browser/gamepad/gamepad_provider.h"
+#include "content/browser/gamepad/gamepad_service.h"
 #include "content/common/gamepad_hardware_buffer.h"
 #include "content/common/gamepad_messages.h"
 #include "content/common/gamepad_user_gesture.h"
 
 namespace content {
+#if defined(OS_ANDROID)
+const int64 GamepadProvider::max_timestamp_before_pause_ = 500;
+#endif
 
 GamepadProvider::ClosureAndThread::ClosureAndThread(
     const base::Closure& c,
     const scoped_refptr<base::MessageLoopProxy>& m)
     : closure(c),
       message_loop(m) {
 }
 
 GamepadProvider::ClosureAndThread::~ClosureAndThread() {
 }
@@ skipping 23 matching lines @@
   data_fetcher_.reset();
 }
 
 base::SharedMemoryHandle GamepadProvider::GetSharedMemoryHandleForProcess(
     base::ProcessHandle process) {
   base::SharedMemoryHandle renderer_handle;
   gamepad_shared_memory_.ShareToProcess(process, &renderer_handle);
   return renderer_handle;
 }
 
+#if defined(OS_ANDROID)
+bool GamepadProvider::GetPollState() {
+  return is_paused_;
+}
+#endif
+
 void GamepadProvider::Pause() {
   {
     base::AutoLock lock(is_paused_lock_);
     is_paused_ = true;
   }
   base::MessageLoop* polling_loop = polling_thread_->message_loop();
   polling_loop->PostTask(
       FROM_HERE,
       base::Bind(&GamepadProvider::SendPauseHint, Unretained(this), true));
 }
@@ skipping 84 matching lines @@
       &hwbuf->buffer,
       sizeof(blink::WebGamepads),
       "Racey reads are discarded");
 
   {
     base::AutoLock lock(devices_changed_lock_);
     changed = devices_changed_;
     devices_changed_ = false;
   }
 
+#if defined(OS_ANDROID)
+  base::TimeDelta timestamp =
+      (base::Time::NowFromSystemTime()) - (
+            GamepadService::GetInstance()->GetGamepadAccessTimestamp());
+
+  if (timestamp.InMilliseconds() > max_timestamp_before_pause_) {
+    Pause();
+    return;
+  }
+#endif
+
   // Acquire the SeqLock. There is only ever one writer to this data.
   // See gamepad_hardware_buffer.h.
   hwbuf->sequence.WriteBegin();
   data_fetcher_->GetGamepadData(&hwbuf->buffer, changed);
   hwbuf->sequence.WriteEnd();
 
   CheckForUserGesture();
 
   // Schedule our next interval of polling.
   ScheduleDoPoll();
@@ skipping 31 matching lines @@
   if (GamepadsHaveUserGesture(SharedMemoryAsHardwareBuffer()->buffer)) {
     for (size_t i = 0; i < user_gesture_observers_.size(); i++) {
       user_gesture_observers_[i].message_loop->PostTask(FROM_HERE,
           user_gesture_observers_[i].closure);
     }
     user_gesture_observers_.clear();
   }
 }
 
 }  // namespace content