content/public/test/mock_render_thread.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/public/test/mock_render_thread.h"
   6
   7 #include "base/message_loop/message_loop_proxy.h"
   8 #include "content/common/frame_messages.h"
   9 #include "content/common/view_messages.h"
  10 #include "content/public/renderer/render_process_observer.h"
  11 #include "content/renderer/render_view_impl.h"
  12 #include "ipc/ipc_message_utils.h"
  13 #include "ipc/ipc_sync_message.h"
  14 #include "ipc/message_filter.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "third_party/WebKit/public/web/WebScriptController.h"
  17
  18 namespace content {
  19
  20 MockRenderThread::MockRenderThread()
  21     : routing_id_(0),
  22       surface_id_(0),
  23       opener_id_(0),
  24       new_window_routing_id_(0),
  25       new_window_main_frame_routing_id_(0),
  26       new_frame_routing_id_(0) {
  27 }
  28
  29 MockRenderThread::~MockRenderThread() {
  30   while (!filters_.empty()) {
  31     scoped_refptr<IPC::MessageFilter> filter = filters_.back();
  32     filters_.pop_back();
  33     filter->OnFilterRemoved();
  34   }
  35 }
  36
  37 // Called by the Widget. Used to send messages to the browser.
  38 // We short-circuit the mechanism and handle the messages right here on this
  39 // class.
  40 bool MockRenderThread::Send(IPC::Message* msg) {
  41   // We need to simulate a synchronous channel, thus we are going to receive
  42   // through this function messages, messages with reply and reply messages.
  43   // We can only handle one synchronous message at a time.
  44   if (msg->is_reply()) {
  45     if (reply_deserializer_) {
  46       reply_deserializer_->SerializeOutputParameters(*msg);
  47       reply_deserializer_.reset();
  48     }
  49   } else {
  50     if (msg->is_sync()) {
  51       // We actually need to handle deleting the reply deserializer for sync
  52       // messages.
  53       reply_deserializer_.reset(
  54           static_cast<IPC::SyncMessage*>(msg)->GetReplyDeserializer());
  55     }
  56     if (msg->routing_id() == MSG_ROUTING_CONTROL)
  57       OnControlMessageReceived(*msg);
  58     else
  59       OnMessageReceived(*msg);
  60   }
  61   delete msg;
  62   return true;
  63 }
  64
  65 base::MessageLoop* MockRenderThread::GetMessageLoop() {
  66   return NULL;
  67 }
  68
  69 IPC::SyncChannel* MockRenderThread::GetChannel() {
  70   return NULL;
  71 }
  72
  73 std::string MockRenderThread::GetLocale() {
  74   return "en-US";
  75 }
  76
  77 IPC::SyncMessageFilter* MockRenderThread::GetSyncMessageFilter() {
  78   return NULL;
  79 }
  80
  81 scoped_refptr<base::MessageLoopProxy>
  82     MockRenderThread::GetIOMessageLoopProxy() {
  83   return scoped_refptr<base::MessageLoopProxy>();
  84 }
  85
  86 void MockRenderThread::AddRoute(int32 routing_id, IPC::Listener* listener) {
  87 }
  88
  89 void MockRenderThread::RemoveRoute(int32 routing_id) {
  90 }
  91
  92 int MockRenderThread::GenerateRoutingID() {
  93   NOTREACHED();
  94   return MSG_ROUTING_NONE;
  95 }
  96
  97 void MockRenderThread::AddFilter(IPC::MessageFilter* filter) {
  98   filter->OnFilterAdded(&sink());
  99   // Add this filter to a vector so the MockRenderThread::RemoveFilter function
 100   // can check if this filter is added.
 101   filters_.push_back(make_scoped_refptr(filter));
 102 }
 103
 104 void MockRenderThread::RemoveFilter(IPC::MessageFilter* filter) {
 105   // Emulate the IPC::ChannelProxy::OnRemoveFilter function.
 106   for (size_t i = 0; i < filters_.size(); ++i) {
 107     if (filters_[i].get() == filter) {
 108       filter->OnFilterRemoved();
 109       filters_.erase(filters_.begin() + i);
 110       return;
 111     }
 112   }
 113   NOTREACHED() << "filter to be removed not found";
 114 }
 115
 116 void MockRenderThread::AddObserver(RenderProcessObserver* observer) {
 117   observers_.AddObserver(observer);
 118 }
 119
 120 void MockRenderThread::RemoveObserver(RenderProcessObserver* observer) {
 121   observers_.RemoveObserver(observer);
 122 }
 123
 124 void MockRenderThread::SetResourceDispatcherDelegate(
 125     ResourceDispatcherDelegate* delegate) {
 126 }
 127
 128 void MockRenderThread::EnsureWebKitInitialized() {
 129 }
 130
 131 void MockRenderThread::RecordAction(const base::UserMetricsAction& action) {
 132 }
 133
 134 void MockRenderThread::RecordComputedAction(const std::string& action) {
 135 }
 136
 137 scoped_ptr<base::SharedMemory>
 138     MockRenderThread::HostAllocateSharedMemoryBuffer(
 139         size_t buffer_size) {
 140   scoped_ptr<base::SharedMemory> shared_buf(new base::SharedMemory);
 141   if (!shared_buf->CreateAnonymous(buffer_size)) {
 142     NOTREACHED() << "Cannot map shared memory buffer";
 143     return scoped_ptr<base::SharedMemory>();
 144   }
 145
 146   return scoped_ptr<base::SharedMemory>(shared_buf.release());
 147 }
 148
 149 void MockRenderThread::RegisterExtension(v8::Extension* extension) {
 150   blink::WebScriptController::registerExtension(extension);
 151 }
 152
 153 void MockRenderThread::ScheduleIdleHandler(int64 initial_delay_ms) {
 154 }
 155
 156 void MockRenderThread::IdleHandler() {
 157 }
 158
 159 int64 MockRenderThread::GetIdleNotificationDelayInMs() const {
 160   return 0;
 161 }
 162
 163 void MockRenderThread::SetIdleNotificationDelayInMs(
 164     int64 idle_notification_delay_in_ms) {
 165 }
 166
 167 void MockRenderThread::UpdateHistograms(int sequence_number) {
 168 }
 169
 170 int MockRenderThread::PostTaskToAllWebWorkers(const base::Closure& closure) {
 171   return 0;
 172 }
 173
 174 bool MockRenderThread::ResolveProxy(const GURL& url, std::string* proxy_list) {
 175   return false;
 176 }
 177
 178 base::WaitableEvent* MockRenderThread::GetShutdownEvent() {
 179   return NULL;
 180 }
 181
 182 #if defined(OS_WIN)
 183 void MockRenderThread::PreCacheFont(const LOGFONT& log_font) {
 184 }
 185
 186 void MockRenderThread::ReleaseCachedFonts() {
 187 }
 188
 189 #endif  // OS_WIN
 190
 191 void MockRenderThread::SendCloseMessage() {
 192   ViewMsg_Close msg(routing_id_);
 193   RenderViewImpl::FromRoutingID(routing_id_)->OnMessageReceived(msg);
 194 }
 195
 196 // The Widget expects to be returned valid route_id.
 197 void MockRenderThread::OnCreateWidget(int opener_id,
 198                                       blink::WebPopupType popup_type,
 199                                       int* route_id,
 200                                       int* surface_id) {
 201   opener_id_ = opener_id;
 202   *route_id = routing_id_;
 203   *surface_id = surface_id_;
 204 }
 205
 206 // The View expects to be returned a valid route_id different from its own.
 207 void MockRenderThread::OnCreateWindow(
 208     const ViewHostMsg_CreateWindow_Params& params,
 209     int* route_id,
 210     int* main_frame_route_id,
 211     int* surface_id,
 212     int64* cloned_session_storage_namespace_id) {
 213   *route_id = new_window_routing_id_;
 214   *main_frame_route_id = new_window_main_frame_routing_id_;
 215   *surface_id = surface_id_;
 216   *cloned_session_storage_namespace_id = 0;
 217 }
 218
 219 // The Frame expects to be returned a valid route_id different from its own.
 220 void MockRenderThread::OnCreateChildFrame(int new_frame_routing_id,
 221                                           const std::string& frame_name,
 222                                           int* new_render_frame_id) {
 223   *new_render_frame_id = new_frame_routing_id_++;
 224 }
 225
 226 bool MockRenderThread::OnControlMessageReceived(const IPC::Message& msg) {
 227   ObserverListBase<RenderProcessObserver>::Iterator it(observers_);
 228   RenderProcessObserver* observer;
 229   while ((observer = it.GetNext()) != NULL) {
 230     if (observer->OnControlMessageReceived(msg))
 231       return true;
 232   }
 233   return OnMessageReceived(msg);
 234 }
 235
 236 bool MockRenderThread::OnMessageReceived(const IPC::Message& msg) {
 237   // Save the message in the sink.
 238   sink_.OnMessageReceived(msg);
 239
 240   bool handled = true;
 241   IPC_BEGIN_MESSAGE_MAP(MockRenderThread, msg)
 242     IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWidget, OnCreateWidget)
 243     IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWindow, OnCreateWindow)
 244     IPC_MESSAGE_HANDLER(FrameHostMsg_CreateChildFrame, OnCreateChildFrame)
 245     IPC_MESSAGE_UNHANDLED(handled = false)
 246   IPC_END_MESSAGE_MAP()
 247   return handled;
 248 }
 249
 250 #if defined(OS_WIN)
 251 void MockRenderThread::OnDuplicateSection(
 252     base::SharedMemoryHandle renderer_handle,
 253     base::SharedMemoryHandle* browser_handle) {
 254   // We don't have to duplicate the input handles since RenderViewTest does not
 255   // separate a browser process from a renderer process.
 256   *browser_handle = renderer_handle;
 257 }
 258 #endif  // defined(OS_WIN)
 259
 260 }  // namespace content