src/content/browser/browser_plugin/test_browser_plugin_guest.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/browser/browser_plugin/test_browser_plugin_guest.h"
   6
   7 #include "base/test/test_timeouts.h"
   8 #include "content/browser/renderer_host/render_view_host_impl.h"
   9 #include "content/browser/web_contents/web_contents_impl.h"
  10 #include "content/common/browser_plugin/browser_plugin_messages.h"
  11
  12 namespace content {
  13
  14 class BrowserPluginGuest;
  15
  16 TestBrowserPluginGuest::TestBrowserPluginGuest(
  17     int instance_id,
  18     WebContentsImpl* web_contents)
  19     : BrowserPluginGuest(instance_id, false, web_contents),
  20       update_rect_count_(0),
  21       exit_observed_(false),
  22       focus_observed_(false),
  23       blur_observed_(false),
  24       advance_focus_observed_(false),
  25       input_observed_(false),
  26       load_stop_observed_(false),
  27       ime_cancel_observed_(false) {
  28 }
  29
  30 TestBrowserPluginGuest::~TestBrowserPluginGuest() {
  31 }
  32
  33 WebContentsImpl* TestBrowserPluginGuest::web_contents() const {
  34   return static_cast<WebContentsImpl*>(BrowserPluginGuest::web_contents());
  35 }
  36
  37 void TestBrowserPluginGuest::SendMessageToEmbedder(IPC::Message* msg) {
  38   if (msg->type() == BrowserPluginMsg_UpdateRect::ID) {
  39     update_rect_count_++;
  40     int instance_id = 0;
  41     BrowserPluginMsg_UpdateRect_Params params;
  42     BrowserPluginMsg_UpdateRect::Read(msg, &instance_id, &params);
  43     last_view_size_observed_ = params.view_size;
  44     if (!expected_auto_view_size_.IsEmpty() &&
  45         expected_auto_view_size_ == params.view_size) {
  46       if (auto_view_size_message_loop_runner_)
  47         auto_view_size_message_loop_runner_->Quit();
  48     }
  49     if (send_message_loop_runner_)
  50       send_message_loop_runner_->Quit();
  51   }
  52   BrowserPluginGuest::SendMessageToEmbedder(msg);
  53 }
  54
  55 void TestBrowserPluginGuest::WaitForUpdateRectMsg() {
  56   // Check if we already got any UpdateRect message.
  57   if (update_rect_count_ > 0)
  58     return;
  59   send_message_loop_runner_ = new MessageLoopRunner();
  60   send_message_loop_runner_->Run();
  61 }
  62
  63 void TestBrowserPluginGuest::ResetUpdateRectCount() {
  64   update_rect_count_ = 0;
  65 }
  66
  67 void TestBrowserPluginGuest::RenderProcessGone(base::TerminationStatus status) {
  68   exit_observed_ = true;
  69   if (status != base::TERMINATION_STATUS_NORMAL_TERMINATION &&
  70       status != base::TERMINATION_STATUS_STILL_RUNNING)
  71     VLOG(0) << "Guest crashed status: " << status;
  72   if (crash_message_loop_runner_)
  73     crash_message_loop_runner_->Quit();
  74   BrowserPluginGuest::RenderProcessGone(status);
  75 }
  76
  77 void TestBrowserPluginGuest::OnHandleInputEvent(
  78     int instance_id,
  79     const gfx::Rect& guest_window_rect,
  80     const blink::WebInputEvent* event) {
  81   BrowserPluginGuest::OnHandleInputEvent(instance_id,
  82                                          guest_window_rect,
  83                                          event);
  84   input_observed_ = true;
  85   if (input_message_loop_runner_)
  86     input_message_loop_runner_->Quit();
  87 }
  88
  89 void TestBrowserPluginGuest::WaitForExit() {
  90   // Check if we already observed a guest crash, return immediately if so.
  91   if (exit_observed_)
  92     return;
  93
  94   crash_message_loop_runner_ = new MessageLoopRunner();
  95   crash_message_loop_runner_->Run();
  96 }
  97
  98 void TestBrowserPluginGuest::WaitForFocus() {
  99   if (focus_observed_) {
 100     focus_observed_ = false;
 101     return;
 102   }
 103   focus_message_loop_runner_ = new MessageLoopRunner();
 104   focus_message_loop_runner_->Run();
 105   focus_observed_ = false;
 106 }
 107
 108 void TestBrowserPluginGuest::WaitForBlur() {
 109   if (blur_observed_) {
 110     blur_observed_ = false;
 111     return;
 112   }
 113   blur_message_loop_runner_ = new MessageLoopRunner();
 114   blur_message_loop_runner_->Run();
 115   blur_observed_ = false;
 116 }
 117
 118 void TestBrowserPluginGuest::WaitForAdvanceFocus() {
 119   if (advance_focus_observed_)
 120     return;
 121   advance_focus_message_loop_runner_ = new MessageLoopRunner();
 122   advance_focus_message_loop_runner_->Run();
 123 }
 124
 125 void TestBrowserPluginGuest::WaitForInput() {
 126   if (input_observed_) {
 127     input_observed_ = false;
 128     return;
 129   }
 130
 131   input_message_loop_runner_ = new MessageLoopRunner();
 132   input_message_loop_runner_->Run();
 133   input_observed_ = false;
 134 }
 135
 136 void TestBrowserPluginGuest::WaitForLoadStop() {
 137   if (load_stop_observed_) {
 138     load_stop_observed_ = false;
 139     return;
 140   }
 141
 142   load_stop_message_loop_runner_ = new MessageLoopRunner();
 143   load_stop_message_loop_runner_->Run();
 144   load_stop_observed_ = false;
 145 }
 146
 147 void TestBrowserPluginGuest::WaitForViewSize(const gfx::Size& view_size) {
 148   if (last_view_size_observed_ == view_size) {
 149     last_view_size_observed_ = gfx::Size();
 150     return;
 151   }
 152
 153   expected_auto_view_size_ = view_size;
 154   auto_view_size_message_loop_runner_ = new MessageLoopRunner();
 155   auto_view_size_message_loop_runner_->Run();
 156   last_view_size_observed_ = gfx::Size();
 157 }
 158
 159 void TestBrowserPluginGuest::WaitForImeCancel() {
 160   if (ime_cancel_observed_) {
 161     ime_cancel_observed_ = false;
 162     return;
 163   }
 164
 165   ime_cancel_message_loop_runner_ = new MessageLoopRunner();
 166   ime_cancel_message_loop_runner_->Run();
 167   ime_cancel_observed_ = false;
 168 }
 169
 170 void TestBrowserPluginGuest::WaitForResizeGuest(const gfx::Size& view_size) {
 171   if (last_size_observed_in_resize_ == view_size) {
 172     last_size_observed_in_resize_ = gfx::Size();
 173     return;
 174   }
 175
 176   expected_view_size_in_resize_ = view_size;
 177   resize_guest_message_loop_runner_ = new MessageLoopRunner();
 178   resize_guest_message_loop_runner_->Run();
 179   last_size_observed_in_resize_ = gfx::Size();
 180 }
 181
 182 void TestBrowserPluginGuest::OnSetFocus(int instance_id, bool focused) {
 183   if (focused) {
 184     focus_observed_ = true;
 185     if (focus_message_loop_runner_)
 186       focus_message_loop_runner_->Quit();
 187   } else {
 188     blur_observed_ = true;
 189     if (blur_message_loop_runner_)
 190       blur_message_loop_runner_->Quit();
 191   }
 192   BrowserPluginGuest::OnSetFocus(instance_id, focused);
 193 }
 194
 195 void TestBrowserPluginGuest::OnTakeFocus(bool reverse) {
 196   advance_focus_observed_ = true;
 197   if (advance_focus_message_loop_runner_)
 198     advance_focus_message_loop_runner_->Quit();
 199   BrowserPluginGuest::OnTakeFocus(reverse);
 200 }
 201
 202 void TestBrowserPluginGuest::DidStopLoading(
 203     RenderViewHost* render_view_host) {
 204   BrowserPluginGuest::DidStopLoading(render_view_host);
 205   load_stop_observed_ = true;
 206   if (load_stop_message_loop_runner_)
 207     load_stop_message_loop_runner_->Quit();
 208 }
 209
 210 void TestBrowserPluginGuest::OnImeCancelComposition() {
 211   if (!ime_cancel_observed_) {
 212     ime_cancel_observed_ = true;
 213     if (ime_cancel_message_loop_runner_)
 214       ime_cancel_message_loop_runner_->Quit();
 215   }
 216   BrowserPluginGuest::OnImeCancelComposition();
 217 }
 218
 219 void TestBrowserPluginGuest::OnResizeGuest(
 220     int instance_id,
 221     const BrowserPluginHostMsg_ResizeGuest_Params& params) {
 222   last_size_observed_in_resize_ = params.view_rect.size();
 223   if (last_size_observed_in_resize_ == expected_view_size_in_resize_ &&
 224       resize_guest_message_loop_runner_) {
 225     resize_guest_message_loop_runner_->Quit();
 226   }
 227
 228   BrowserPluginGuest::OnResizeGuest(instance_id, params);
 229 }
 230
 231 }  // namespace content