Gamepad: don't notify about connected pads twice

content/browser/gamepad/gamepad_provider.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"
@@ skipping 157 matching lines @@
 
 bool GamepadProvider::PadState::Match(const WebGamepad& pad) const {
   return connected_ == pad.connected &&
          axes_length_ == pad.axesLength &&
          buttons_length_ == pad.buttonsLength &&
          memcmp(id_, pad.id, arraysize(id_)) == 0 &&
          memcmp(mapping_, pad.mapping, arraysize(mapping_)) == 0;
 }
 
 void GamepadProvider::PadState::SetPad(const WebGamepad& pad) {
-  DCHECK(pad.connected);
-  connected_ = true;
+  connected_ = pad.connected;
   axes_length_ = pad.axesLength;
   buttons_length_ = pad.buttonsLength;
   memcpy(id_, pad.id, arraysize(id_));
   memcpy(mapping_, pad.mapping, arraysize(mapping_));
 }
 
 void GamepadProvider::PadState::SetDisconnected() {
   connected_ = false;
   axes_length_ = 0;
   buttons_length_ = 0;
@@ skipping 33 matching lines @@
   {
     base::AutoLock lock(shared_memory_lock_);
 
     // 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();
-
   if (ever_had_user_gesture_) {
     for (unsigned i = 0; i < WebGamepads::itemsLengthCap; ++i) {
       WebGamepad& pad = hwbuf->buffer.items[i];
       PadState& state = pad_states_.get()[i];
       if (pad.connected && !state.connected()) {
         OnGamepadConnectionChange(true, i, pad);
       } else if (!pad.connected && state.connected()) {
         OnGamepadConnectionChange(false, i, pad);
       } else if (pad.connected && state.connected() && !state.Match(pad)) {
         WebGamepad old_pad;
         state.AsWebGamepad(&old_pad);
         OnGamepadConnectionChange(false, i, old_pad);
         OnGamepadConnectionChange(true, i, pad);
       }
     }
   }
 
+  CheckForUserGesture();
+
   // Schedule our next interval of polling.
   ScheduleDoPoll();
 }
 
 void GamepadProvider::ScheduleDoPoll() {
   DCHECK(base::MessageLoop::current() == polling_thread_->message_loop());
   if (have_scheduled_do_poll_)
     return;
 
   {
@@ skipping 39 matching lines @@
   void* mem = gamepad_shared_memory_.memory();
   CHECK(mem);
   return static_cast<GamepadHardwareBuffer*>(mem);
 }
 
 void GamepadProvider::CheckForUserGesture() {
   base::AutoLock lock(user_gesture_lock_);
   if (user_gesture_observers_.empty() && ever_had_user_gesture_)
     return;
 
-  if (GamepadsHaveUserGesture(SharedMemoryAsHardwareBuffer()->buffer)) {
+  bool had_gesture_before = ever_had_user_gesture_;
+  const WebGamepads& pads = SharedMemoryAsHardwareBuffer()->buffer;
+  if (GamepadsHaveUserGesture(pads)) {
     ever_had_user_gesture_ = true;
     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();
   }
+  if (!had_gesture_before && ever_had_user_gesture_) {
+    // Initialize pad_states_ for the first time.
+    for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
+      pad_states_.get()[i].SetPad(pads.items[i]);
+    }
+  }
 }
 
 }  // namespace content