Home | History | Annotate | Download | only in browser_plugin 
      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 #include "content/public/browser/notification_types.h"
     12 
     13 namespace content {
     14 
     15 class BrowserPluginGuest;
     16 
     17 TestBrowserPluginGuest::TestBrowserPluginGuest(
     18     int instance_id,
     19     WebContentsImpl* web_contents)
     20     : BrowserPluginGuest(instance_id, web_contents, NULL, false),
     21       update_rect_count_(0),
     22       damage_buffer_call_count_(0),
     23       exit_observed_(false),
     24       focus_observed_(false),
     25       blur_observed_(false),
     26       advance_focus_observed_(false),
     27       was_hidden_observed_(false),
     28       set_damage_buffer_observed_(false),
     29       input_observed_(false),
     30       load_stop_observed_(false),
     31       waiting_for_damage_buffer_with_size_(false),
     32       last_damage_buffer_size_(gfx::Size()) {
     33   // Listen to visibility changes so that a test can wait for these changes.
     34   notification_registrar_.Add(this,
     35                               NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
     36                               Source<WebContents>(web_contents));
     37 }
     38 
     39 TestBrowserPluginGuest::~TestBrowserPluginGuest() {
     40 }
     41 
     42 WebContentsImpl* TestBrowserPluginGuest::web_contents() const {
     43   return static_cast<WebContentsImpl*>(BrowserPluginGuest::web_contents());
     44 }
     45 
     46 void TestBrowserPluginGuest::Observe(int type,
     47                                      const NotificationSource& source,
     48                                      const NotificationDetails& details) {
     49   switch (type) {
     50     case NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED: {
     51       bool visible = *Details<bool>(details).ptr();
     52       if (!visible) {
     53         was_hidden_observed_ = true;
     54         if (was_hidden_message_loop_runner_.get())
     55           was_hidden_message_loop_runner_->Quit();
     56       }
     57       return;
     58     }
     59   }
     60 
     61   BrowserPluginGuest::Observe(type, source, details);
     62 }
     63 
     64 void TestBrowserPluginGuest::SendMessageToEmbedder(IPC::Message* msg) {
     65   if (msg->type() == BrowserPluginMsg_UpdateRect::ID) {
     66     update_rect_count_++;
     67     int instance_id = 0;
     68     BrowserPluginMsg_UpdateRect_Params params;
     69     BrowserPluginMsg_UpdateRect::Read(msg, &instance_id, &params);
     70     last_view_size_observed_ = params.view_size;
     71     if (!expected_auto_view_size_.IsEmpty() &&
     72         expected_auto_view_size_ == params.view_size) {
     73       if (auto_view_size_message_loop_runner_.get())
     74         auto_view_size_message_loop_runner_->Quit();
     75     }
     76     if (send_message_loop_runner_.get())
     77       send_message_loop_runner_->Quit();
     78   }
     79   BrowserPluginGuest::SendMessageToEmbedder(msg);
     80 }
     81 
     82 void TestBrowserPluginGuest::WaitForUpdateRectMsg() {
     83   // Check if we already got any UpdateRect message.
     84   if (update_rect_count_ > 0)
     85     return;
     86   send_message_loop_runner_ = new MessageLoopRunner();
     87   send_message_loop_runner_->Run();
     88 }
     89 
     90 void TestBrowserPluginGuest::ResetUpdateRectCount() {
     91   update_rect_count_ = 0;
     92 }
     93 
     94 void TestBrowserPluginGuest::WaitForDamageBufferWithSize(
     95     const gfx::Size& size) {
     96   if (damage_buffer_call_count_ > 0 && last_damage_buffer_size_ == size)
     97     return;
     98 
     99   expected_damage_buffer_size_ = size;
    100   waiting_for_damage_buffer_with_size_ = true;
    101   damage_buffer_message_loop_runner_ = new MessageLoopRunner();
    102   damage_buffer_message_loop_runner_->Run();
    103 }
    104 
    105 void TestBrowserPluginGuest::RenderProcessGone(base::TerminationStatus status) {
    106   exit_observed_ = true;
    107   if (status != base::TERMINATION_STATUS_NORMAL_TERMINATION &&
    108       status != base::TERMINATION_STATUS_STILL_RUNNING)
    109     LOG(INFO) << "Guest crashed status: " << status;
    110   if (crash_message_loop_runner_.get())
    111     crash_message_loop_runner_->Quit();
    112   BrowserPluginGuest::RenderProcessGone(status);
    113 }
    114 
    115 void TestBrowserPluginGuest::OnHandleInputEvent(
    116     int instance_id,
    117     const gfx::Rect& guest_window_rect,
    118     const WebKit::WebInputEvent* event) {
    119   BrowserPluginGuest::OnHandleInputEvent(instance_id,
    120                                          guest_window_rect,
    121                                          event);
    122   input_observed_ = true;
    123   if (input_message_loop_runner_.get())
    124     input_message_loop_runner_->Quit();
    125 }
    126 
    127 void TestBrowserPluginGuest::WaitForExit() {
    128   // Check if we already observed a guest crash, return immediately if so.
    129   if (exit_observed_)
    130     return;
    131 
    132   crash_message_loop_runner_ = new MessageLoopRunner();
    133   crash_message_loop_runner_->Run();
    134 }
    135 
    136 void TestBrowserPluginGuest::WaitForFocus() {
    137   if (focus_observed_) {
    138     focus_observed_ = false;
    139     return;
    140   }
    141   focus_message_loop_runner_ = new MessageLoopRunner();
    142   focus_message_loop_runner_->Run();
    143   focus_observed_ = false;
    144 }
    145 
    146 void TestBrowserPluginGuest::WaitForBlur() {
    147   if (blur_observed_) {
    148     blur_observed_ = false;
    149     return;
    150   }
    151   blur_message_loop_runner_ = new MessageLoopRunner();
    152   blur_message_loop_runner_->Run();
    153   blur_observed_ = false;
    154 }
    155 
    156 void TestBrowserPluginGuest::WaitForAdvanceFocus() {
    157   if (advance_focus_observed_)
    158     return;
    159   advance_focus_message_loop_runner_ = new MessageLoopRunner();
    160   advance_focus_message_loop_runner_->Run();
    161 }
    162 
    163 void TestBrowserPluginGuest::WaitUntilHidden() {
    164   if (was_hidden_observed_) {
    165     was_hidden_observed_ = false;
    166     return;
    167   }
    168   was_hidden_message_loop_runner_ = new MessageLoopRunner();
    169   was_hidden_message_loop_runner_->Run();
    170   was_hidden_observed_ = false;
    171 }
    172 
    173 void TestBrowserPluginGuest::WaitForInput() {
    174   if (input_observed_) {
    175     input_observed_ = false;
    176     return;
    177   }
    178 
    179   input_message_loop_runner_ = new MessageLoopRunner();
    180   input_message_loop_runner_->Run();
    181   input_observed_ = false;
    182 }
    183 
    184 void TestBrowserPluginGuest::WaitForLoadStop() {
    185   if (load_stop_observed_) {
    186     load_stop_observed_ = false;
    187     return;
    188   }
    189 
    190   load_stop_message_loop_runner_ = new MessageLoopRunner();
    191   load_stop_message_loop_runner_->Run();
    192   load_stop_observed_ = false;
    193 }
    194 
    195 void TestBrowserPluginGuest::WaitForViewSize(const gfx::Size& view_size) {
    196   if (last_view_size_observed_ == view_size) {
    197     last_view_size_observed_ = gfx::Size();
    198     return;
    199   }
    200 
    201   expected_auto_view_size_ = view_size;
    202   auto_view_size_message_loop_runner_ = new MessageLoopRunner();
    203   auto_view_size_message_loop_runner_->Run();
    204   last_view_size_observed_ = gfx::Size();
    205 }
    206 
    207 void TestBrowserPluginGuest::OnSetFocus(int instance_id, bool focused) {
    208   if (focused) {
    209     focus_observed_ = true;
    210     if (focus_message_loop_runner_.get())
    211       focus_message_loop_runner_->Quit();
    212   } else {
    213     blur_observed_ = true;
    214     if (blur_message_loop_runner_.get())
    215       blur_message_loop_runner_->Quit();
    216   }
    217   BrowserPluginGuest::OnSetFocus(instance_id, focused);
    218 }
    219 
    220 void TestBrowserPluginGuest::OnTakeFocus(bool reverse) {
    221   advance_focus_observed_ = true;
    222   if (advance_focus_message_loop_runner_.get())
    223     advance_focus_message_loop_runner_->Quit();
    224   BrowserPluginGuest::OnTakeFocus(reverse);
    225 }
    226 
    227 void TestBrowserPluginGuest::SetDamageBuffer(
    228     const BrowserPluginHostMsg_ResizeGuest_Params& params) {
    229   ++damage_buffer_call_count_;
    230   last_damage_buffer_size_ = params.view_rect.size();
    231 
    232   if (waiting_for_damage_buffer_with_size_ &&
    233       expected_damage_buffer_size_ == params.view_rect.size() &&
    234       damage_buffer_message_loop_runner_.get()) {
    235     damage_buffer_message_loop_runner_->Quit();
    236     waiting_for_damage_buffer_with_size_ = false;
    237   }
    238 
    239   BrowserPluginGuest::SetDamageBuffer(params);
    240 }
    241 
    242 void TestBrowserPluginGuest::DidStopLoading(
    243     RenderViewHost* render_view_host) {
    244   BrowserPluginGuest::DidStopLoading(render_view_host);
    245   load_stop_observed_ = true;
    246   if (load_stop_message_loop_runner_.get())
    247     load_stop_message_loop_runner_->Quit();
    248 }
    249 
    250 }  // namespace content
    251