src/content/public/test/mock_render_process_host.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_process_host.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/time/time.h"
  10 #include "content/browser/child_process_security_policy_impl.h"
  11 #include "content/browser/renderer_host/render_process_host_impl.h"
  12 #include "content/browser/renderer_host/render_view_host_impl.h"
  13 #include "content/browser/renderer_host/render_widget_host_impl.h"
  14 #include "content/common/child_process_host_impl.h"
  15 #include "content/public/browser/notification_service.h"
  16 #include "content/public/browser/notification_types.h"
  17 #include "content/public/browser/render_widget_host_iterator.h"
  18 #include "content/public/browser/storage_partition.h"
  19
  20 namespace content {
  21
  22 MockRenderProcessHost::MockRenderProcessHost(
  23     BrowserContext* browser_context)
  24         : transport_dib_(NULL),
  25           bad_msg_count_(0),
  26           factory_(NULL),
  27           id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()),
  28           browser_context_(browser_context),
  29           prev_routing_id_(0),
  30           fast_shutdown_started_(false) {
  31   // Child process security operations can't be unit tested unless we add
  32   // ourselves as an existing child process.
  33   ChildProcessSecurityPolicyImpl::GetInstance()->Add(GetID());
  34
  35   RenderProcessHostImpl::RegisterHost(GetID(), this);
  36 }
  37
  38 MockRenderProcessHost::~MockRenderProcessHost() {
  39   ChildProcessSecurityPolicyImpl::GetInstance()->Remove(GetID());
  40   delete transport_dib_;
  41   if (factory_)
  42     factory_->Remove(this);
  43   // In unit tests, Release() might not have been called.
  44   RenderProcessHostImpl::UnregisterHost(GetID());
  45 }
  46
  47 void MockRenderProcessHost::EnableSendQueue() {
  48 }
  49
  50 bool MockRenderProcessHost::Init() {
  51   return true;
  52 }
  53
  54 int MockRenderProcessHost::GetNextRoutingID() {
  55   return ++prev_routing_id_;
  56 }
  57
  58 void MockRenderProcessHost::AddRoute(
  59     int32 routing_id,
  60     IPC::Listener* listener) {
  61   listeners_.AddWithID(listener, routing_id);
  62 }
  63
  64 void MockRenderProcessHost::RemoveRoute(int32 routing_id) {
  65   DCHECK(listeners_.Lookup(routing_id) != NULL);
  66   listeners_.Remove(routing_id);
  67   Cleanup();
  68 }
  69
  70 bool MockRenderProcessHost::WaitForBackingStoreMsg(
  71     int render_widget_id,
  72     const base::TimeDelta& max_delay,
  73     IPC::Message* msg) {
  74   return false;
  75 }
  76
  77 void MockRenderProcessHost::ReceivedBadMessage() {
  78   ++bad_msg_count_;
  79 }
  80
  81 void MockRenderProcessHost::WidgetRestored() {
  82 }
  83
  84 void MockRenderProcessHost::WidgetHidden() {
  85 }
  86
  87 int MockRenderProcessHost::VisibleWidgetCount() const {
  88   return 1;
  89 }
  90
  91 bool MockRenderProcessHost::IsGuest() const {
  92   return false;
  93 }
  94
  95 StoragePartition* MockRenderProcessHost::GetStoragePartition() const {
  96   return NULL;
  97 }
  98
  99 void MockRenderProcessHost::AddWord(const string16& word) {
 100 }
 101
 102 bool MockRenderProcessHost::FastShutdownIfPossible() {
 103   // We aren't actually going to do anything, but set |fast_shutdown_started_|
 104   // to true so that tests know we've been called.
 105   fast_shutdown_started_ = true;
 106   return true;
 107 }
 108
 109 bool MockRenderProcessHost::FastShutdownStarted() const {
 110   return fast_shutdown_started_;
 111 }
 112
 113 void MockRenderProcessHost::DumpHandles() {
 114 }
 115
 116 base::ProcessHandle MockRenderProcessHost::GetHandle() const {
 117   // Return the current-process handle for the IPC::GetFileHandleForProcess
 118   // function.
 119   return base::Process::Current().handle();
 120 }
 121
 122 bool MockRenderProcessHost::Send(IPC::Message* msg) {
 123   // Save the message in the sink.
 124   sink_.OnMessageReceived(*msg);
 125   delete msg;
 126   return true;
 127 }
 128
 129 TransportDIB* MockRenderProcessHost::MapTransportDIB(TransportDIB::Id dib_id) {
 130 #if defined(OS_WIN)
 131   HANDLE duped;
 132   DuplicateHandle(GetCurrentProcess(), dib_id.handle, GetCurrentProcess(),
 133                   &duped, 0, TRUE, DUPLICATE_SAME_ACCESS);
 134   return TransportDIB::Map(duped);
 135 #elif defined(TOOLKIT_GTK)
 136   return TransportDIB::Map(dib_id.shmkey);
 137 #elif defined(OS_ANDROID)
 138   // On Android, Handles and Ids are the same underlying type.
 139   return TransportDIB::Map(dib_id);
 140 #else
 141   // On POSIX, TransportDIBs are always created in the browser, so we cannot map
 142   // one from a dib_id.
 143   return TransportDIB::Create(100 * 100 * 4, 0);
 144 #endif
 145 }
 146
 147 TransportDIB* MockRenderProcessHost::GetTransportDIB(TransportDIB::Id dib_id) {
 148   if (transport_dib_)
 149     return transport_dib_;
 150
 151   transport_dib_ = MapTransportDIB(dib_id);
 152   return transport_dib_;
 153 }
 154
 155 int MockRenderProcessHost::GetID() const {
 156   return id_;
 157 }
 158
 159 bool MockRenderProcessHost::HasConnection() const {
 160   return true;
 161 }
 162
 163 void MockRenderProcessHost::SetIgnoreInputEvents(bool ignore_input_events) {
 164 }
 165
 166 bool MockRenderProcessHost::IgnoreInputEvents() const {
 167   return false;
 168 }
 169
 170 void MockRenderProcessHost::Cleanup() {
 171   if (listeners_.IsEmpty()) {
 172     NotificationService::current()->Notify(
 173         NOTIFICATION_RENDERER_PROCESS_TERMINATED,
 174         Source<RenderProcessHost>(this),
 175         NotificationService::NoDetails());
 176     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 177     RenderProcessHostImpl::UnregisterHost(GetID());
 178   }
 179 }
 180
 181 void MockRenderProcessHost::AddPendingView() {
 182 }
 183
 184 void MockRenderProcessHost::RemovePendingView() {
 185 }
 186
 187 void MockRenderProcessHost::SetSuddenTerminationAllowed(bool allowed) {
 188 }
 189
 190 bool MockRenderProcessHost::SuddenTerminationAllowed() const {
 191   return true;
 192 }
 193
 194 BrowserContext* MockRenderProcessHost::GetBrowserContext() const {
 195   return browser_context_;
 196 }
 197
 198 bool MockRenderProcessHost::InSameStoragePartition(
 199     StoragePartition* partition) const {
 200   // Mock RPHs only have one partition.
 201   return true;
 202 }
 203
 204 IPC::ChannelProxy* MockRenderProcessHost::GetChannel() {
 205   return NULL;
 206 }
 207
 208 void MockRenderProcessHost::AddFilter(BrowserMessageFilter* filter) {
 209 }
 210
 211 int MockRenderProcessHost::GetActiveViewCount() {
 212   int num_active_views = 0;
 213   scoped_ptr<RenderWidgetHostIterator> widgets(
 214       RenderWidgetHost::GetRenderWidgetHosts());
 215   while (RenderWidgetHost* widget = widgets->GetNextHost()) {
 216     // Count only RenderWidgetHosts in this process.
 217     if (widget->GetProcess()->GetID() == GetID())
 218       num_active_views++;
 219   }
 220   return num_active_views;
 221 }
 222
 223 bool MockRenderProcessHost::FastShutdownForPageCount(size_t count) {
 224   if (static_cast<size_t>(GetActiveViewCount()) == count)
 225     return FastShutdownIfPossible();
 226   return false;
 227 }
 228
 229 base::TimeDelta MockRenderProcessHost::GetChildProcessIdleTime() const {
 230   return base::TimeDelta::FromMilliseconds(0);
 231 }
 232
 233 void MockRenderProcessHost::SurfaceUpdated(int32 surface_id) {
 234 }
 235
 236 void MockRenderProcessHost::ResumeRequestsForView(int route_id) {
 237 }
 238
 239
 240 bool MockRenderProcessHost::OnMessageReceived(const IPC::Message& msg) {
 241   IPC::Listener* listener = listeners_.Lookup(msg.routing_id());
 242   if (listener)
 243     return listener->OnMessageReceived(msg);
 244   return false;
 245 }
 246
 247 void MockRenderProcessHost::OnChannelConnected(int32 peer_pid) {
 248 }
 249
 250 MockRenderProcessHostFactory::MockRenderProcessHostFactory() {}
 251
 252 MockRenderProcessHostFactory::~MockRenderProcessHostFactory() {
 253   // Detach this object from MockRenderProcesses to prevent STLDeleteElements()
 254   // from calling MockRenderProcessHostFactory::Remove().
 255   for (ScopedVector<MockRenderProcessHost>::iterator it = processes_.begin();
 256        it != processes_.end(); ++it) {
 257     (*it)->SetFactory(NULL);
 258   }
 259 }
 260
 261 RenderProcessHost* MockRenderProcessHostFactory::CreateRenderProcessHost(
 262     BrowserContext* browser_context,
 263     SiteInstance* site_instance) const {
 264   MockRenderProcessHost* host = new MockRenderProcessHost(browser_context);
 265   if (host) {
 266     processes_.push_back(host);
 267     host->SetFactory(this);
 268   }
 269   return host;
 270 }
 271
 272 void MockRenderProcessHostFactory::Remove(MockRenderProcessHost* host) const {
 273   for (ScopedVector<MockRenderProcessHost>::iterator it = processes_.begin();
 274        it != processes_.end(); ++it) {
 275     if (*it == host) {
 276       processes_.weak_erase(it);
 277       break;
 278     }
 279   }
 280 }
 281
 282 }  // content