Replace std::map with base::SmallMap in ui::LatencyInfo

ui/aura/window_event_dispatcher_unittest.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 "ui/aura/window_event_dispatcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 1604 matching lines @@
   virtual ~WindowEventDispatcherTestWithMessageLoop() {}
 
   void RunTest() {
     // Reset any event the window may have received when bringing up the window
     // (e.g. mouse-move events if the mouse cursor is over the window).
     handler_.Reset();
 
     // Start a nested message-loop, post an event to be dispatched, and then
     // terminate the message-loop. When the message-loop unwinds and gets back,
     // the reposted event should not have fired.
-    ui::MouseEvent mouse(ui::ET_MOUSE_PRESSED, gfx::Point(10, 10),
-                         gfx::Point(10, 10), ui::EF_NONE, ui::EF_NONE);
-    message_loop()->PostTask(FROM_HERE,
-                             base::Bind(&WindowEventDispatcher::RepostEvent,
-                                        base::Unretained(host()->dispatcher()),
-                                        mouse));
-    message_loop()->PostTask(FROM_HERE,
-                             message_loop()->QuitClosure());
+    scoped_ptr<ui::MouseEvent> mouse(new ui::MouseEvent(ui::ET_MOUSE_PRESSED,
+                                                        gfx::Point(10, 10),
+                                                        gfx::Point(10, 10),
+                                                        ui::EF_NONE,
+                                                        ui::EF_NONE));
+    message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&WindowEventDispatcherTestWithMessageLoop::RepostEventHelper,
+                   host()->dispatcher(),
+                   base::Passed(&mouse)));
+    message_loop()->PostTask(FROM_HERE, message_loop()->QuitClosure());
 
     base::MessageLoop::ScopedNestableTaskAllower allow(message_loop());
     base::RunLoop loop;
     loop.Run();
     EXPECT_EQ(0, handler_.num_mouse_events());
 
     // Let the current message-loop run. The event-handler will terminate the
     // message-loop when it receives the reposted event.
   }
 
   base::MessageLoop* message_loop() {
     return base::MessageLoopForUI::current();
   }
 
  protected:
   virtual void SetUp() OVERRIDE {
     WindowEventDispatcherTest::SetUp();
     window_.reset(CreateNormalWindow(1, root_window(), NULL));
     window_->AddPreTargetHandler(&handler_);
   }
 
   virtual void TearDown() OVERRIDE {
     window_.reset();
     WindowEventDispatcherTest::TearDown();
   }
 
  private:
+  // Used to avoid a copying |event| when binding to a closure.
+  static void RepostEventHelper(WindowEventDispatcher* dispatcher,
+                                scoped_ptr<ui::MouseEvent> event) {
+    dispatcher->RepostEvent(*event);
+  }
+
   scoped_ptr<Window> window_;
   ExitMessageLoopOnMousePress handler_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowEventDispatcherTestWithMessageLoop);
 };
 
 TEST_F(WindowEventDispatcherTestWithMessageLoop, EventRepostedInNonNestedLoop) {
   CHECK(!message_loop()->is_running());
   // Perform the test in a callback, so that it runs after the message-loop
   // starts.
@@ skipping 267 matching lines @@
   EXPECT_TRUE(details.target_destroyed);
   EXPECT_EQ(first.get(), move.target());
   EXPECT_TRUE(dispatch_event.dispatched());
   EXPECT_EQ(second_root, first->GetRootWindow());
 
   first->RemovePreTargetHandler(&dispatch_event);
   second->RemovePreTargetHandler(&move_window);
 }
 
 }  // namespace aura