Sync ui/events to chromium @ https://codereview.chromium.org/1210203002

ui/events/platform/platform_event_source_unittest.cc

 // Copyright 2014 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 "ui/events/platform/platform_event_source.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 47 matching lines @@
     stop_stream_ = false;
     for (size_t count = 0; count < events.size(); ++count) {
       DispatchEvent(*events[count]);
       if (stop_stream_)
         return count + 1;
     }
     return events.size();
   }
 
   // PlatformEventSource:
-  void StopCurrentEventStream() override {
-    stop_stream_ = true;
-  }
+  void StopCurrentEventStream() override { stop_stream_ = true; }
 
  private:
   bool stop_stream_;
   DISALLOW_COPY_AND_ASSIGN(TestPlatformEventSource);
 };
 
 class TestPlatformEventDispatcher : public PlatformEventDispatcher {
  public:
   TestPlatformEventDispatcher(int id, std::vector<int>* list)
       : id_(id),
         list_(list),
-        post_dispatch_action_(POST_DISPATCH_NONE),
-        stop_stream_(false) {
+        post_dispatch_action_(POST_DISPATCH_NONE) {
     PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
   }
   ~TestPlatformEventDispatcher() override {
     PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
   }
 
   void set_post_dispatch_action(uint32_t action) {
     post_dispatch_action_ = action;
   }
 
  protected:
   // PlatformEventDispatcher:
-  bool CanDispatchEvent(const PlatformEvent& event) override {
-    return true;
-  }
+  bool CanDispatchEvent(const PlatformEvent& event) override { return true; }
 
   uint32_t DispatchEvent(const PlatformEvent& event) override {
     list_->push_back(id_);
     return post_dispatch_action_;
   }
 
  private:
   int id_;
   std::vector<int>* list_;
   uint32_t post_dispatch_action_;
-  bool stop_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformEventDispatcher);
 };
 
 class TestPlatformEventObserver : public PlatformEventObserver {
  public:
   TestPlatformEventObserver(int id, std::vector<int>* list)
       : id_(id), list_(list) {
     PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
   }
@@ skipping 18 matching lines @@
 
 class PlatformEventTest : public testing::Test {
  public:
   PlatformEventTest() {}
   ~PlatformEventTest() override {}
 
   TestPlatformEventSource* source() { return source_.get(); }
 
  protected:
   // testing::Test:
-  void SetUp() override {
-    source_.reset(new TestPlatformEventSource());
-  }
+  void SetUp() override { source_.reset(new TestPlatformEventSource()); }
 
  private:
   scoped_ptr<TestPlatformEventSource> source_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformEventTest);
 };
 
 // Tests that a dispatcher receives an event.
 TEST_F(PlatformEventTest, DispatcherBasic) {
   std::vector<int> list_dispatcher;
@@ skipping 413 matching lines @@
   void SetScopedHandle(scoped_ptr<ScopedEventDispatcher> handler) {
     handler_ = handler.Pass();
   }
 
   void set_callback(const base::Closure& callback) {
     callback_ = callback;
   }
 
  private:
   // PlatformEventDispatcher:
-  bool CanDispatchEvent(const PlatformEvent& event) override {
-    return true;
-  }
+  bool CanDispatchEvent(const PlatformEvent& event) override { return true; }
 
   uint32_t DispatchEvent(const PlatformEvent& event) override {
     handler_.reset();
     uint32_t action = TestPlatformEventDispatcher::DispatchEvent(event);
     if (!callback_.is_null()) {
       callback_.Run();
       callback_ = base::Closure();
     }
     return action;
   }
 
   scoped_ptr<ScopedEventDispatcher> handler_;
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyScopedHandleDispatcher);
 };
 
 // Tests that resetting an overridden dispatcher causes the nested message-loop
 // iteration to stop and the rest of the events are dispatched in the next
 // iteration.
 class DestroyedNestedOverriddenDispatcherQuitsNestedLoopIteration
     : public PlatformEventTestWithMessageLoop {
  public:
   void NestedTask(std::vector<int>* list,
                   TestPlatformEventDispatcher* dispatcher) {
     ScopedVector<PlatformEvent> events;
     scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
-    events.push_back(event.release());
+    events.push_back(event.Pass());
     event = CreatePlatformEvent();
-    events.push_back(event.release());
+    events.push_back(event.Pass());
 
     // Attempt to dispatch a couple of events. Dispatching the first event will
     // have terminated the ScopedEventDispatcher object, which will terminate
     // the current iteration of the message-loop.
     size_t count = source()->DispatchEventStream(events);
     EXPECT_EQ(1u, count);
     ASSERT_EQ(2u, list->size());
     EXPECT_EQ(15, (*list)[0]);
     EXPECT_EQ(20, (*list)[1]);
     list->clear();
@@ skipping 151 matching lines @@
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(10, list[1]);
   }
 };
 
 RUN_TEST_IN_MESSAGE_LOOP(
     ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration)
 
 }  // namespace ui