Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/renderer/gpu/input_event_filter_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 <new>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
@@ skipping 118 matching lines @@
 }  // namespace
 
 class InputEventFilterTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
     filter_ = new InputEventFilter(
         &message_recorder_,
         message_loop_.message_loop_proxy(),
         base::Bind(&InputEventRecorder::HandleInputEvent,
             base::Unretained(&event_recorder_)));
-    event_recorder_.set_filter(filter_);
+    event_recorder_.set_filter(filter_.get());
 
     filter_->OnFilterAdded(&ipc_sink_);
   }
 
 
  protected:
   base::MessageLoop message_loop_;
 
   // Used to record IPCs sent by the filter to the RenderWidgetHost.
   IPC::TestSink ipc_sink_;
 
   // Used to record IPCs forwarded by the filter to the main thread.
   IPCMessageRecorder message_recorder_;
 
   // Used to record WebInputEvents delivered to the handler.
   InputEventRecorder event_recorder_;
 
   scoped_refptr<InputEventFilter> filter_;
 };
 
 TEST_F(InputEventFilterTest, Basic) {
   WebMouseEvent kEvents[3];
   InitMouseEvent(&kEvents[0], WebInputEvent::MouseDown, 10, 10);
   InitMouseEvent(&kEvents[1], WebInputEvent::MouseMove, 20, 20);
   InitMouseEvent(&kEvents[2], WebInputEvent::MouseUp, 30, 30);
 
-  AddEventsToFilter(filter_, kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(0U, ipc_sink_.message_count());
   EXPECT_EQ(0U, event_recorder_.record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
 
   filter_->AddRoute(kTestRoutingID);
 
-  AddEventsToFilter(filter_, kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   ASSERT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   ASSERT_EQ(arraysize(kEvents), event_recorder_.record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
 
   for (size_t i = 0; i < arraysize(kEvents); ++i) {
     const IPC::Message* message = ipc_sink_.GetMessageAt(i);
     EXPECT_EQ(kTestRoutingID, message->routing_id());
     EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type());
 
     WebInputEvent::Type event_type = WebInputEvent::Undefined;
     InputEventAckState ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
     EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message,
                                                             &event_type,
                                                             &ack_result));
     EXPECT_EQ(kEvents[i].type, event_type);
     EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 
     const WebInputEvent* event = event_recorder_.record_at(i);
     ASSERT_TRUE(event);
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
   }
 
   event_recorder_.set_send_to_widget(true);
 
-  AddEventsToFilter(filter_, kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   EXPECT_EQ(2 * arraysize(kEvents), event_recorder_.record_count());
   EXPECT_EQ(arraysize(kEvents), message_recorder_.message_count());
 
   for (size_t i = 0; i < arraysize(kEvents); ++i) {
     const IPC::Message& message = message_recorder_.message_at(i);
 
     ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
     const WebInputEvent* event = InputEventFilter::CrackMessage(message);
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
   }
 
   // Now reset everything, and test that DidHandleInputEvent is called.
 
   ipc_sink_.ClearMessages();
   event_recorder_.Clear();
   message_recorder_.Clear();
 
   event_recorder_.set_handle_events(true);
 
-  AddEventsToFilter(filter_, kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
 
   for (size_t i = 0; i < arraysize(kEvents); ++i) {
     const IPC::Message* message = ipc_sink_.GetMessageAt(i);
     EXPECT_EQ(kTestRoutingID, message->routing_id());
     EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type());
 
     WebInputEvent::Type event_type = WebInputEvent::Undefined;
@@ skipping 45 matching lines @@
   messages.push_back(InputMsg_SelectAll(kTestRoutingID));
   messages.push_back(InputMsg_Unselect(kTestRoutingID));
   messages.push_back(InputMsg_SelectRange(kTestRoutingID,
                                          gfx::Point(), gfx::Point()));
   messages.push_back(InputMsg_MoveCaret(kTestRoutingID, gfx::Point()));
 
   messages.push_back(InputMsg_HandleInputEvent(kTestRoutingID,
                                               &mouse_up,
                                               ui::LatencyInfo(),
                                               false));
-  AddMessagesToFilter(filter_, messages);
+  AddMessagesToFilter(filter_.get(), messages);
 
   // We should have sent all messages back to the main thread and preserved
   // their relative order.
   ASSERT_EQ(message_recorder_.message_count(), messages.size());
   for (size_t i = 0; i < messages.size(); ++i) {
     EXPECT_EQ(message_recorder_.message_at(i).type(), messages[i].type()) << i;
   }
 }
 
 }  // namespace content