[BrowserTag] Send dib info with NavigateGuest message,

content/browser/browser_plugin/test_browser_plugin_guest.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 "content/browser/browser_plugin/test_browser_plugin_guest.h"
 
 #include "base/test/test_timeouts.h"
-#include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/browser_plugin_messages.h"
-#include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_types.h"
-#include "content/public/test/test_utils.h"
-#include "ui/gfx/size.h"
 
 namespace content {
 
 class BrowserPluginGuest;
 
 TestBrowserPluginGuest::TestBrowserPluginGuest(
     int instance_id,
     WebContentsImpl* web_contents,
     RenderViewHost* render_view_host)
     : BrowserPluginGuest(instance_id, web_contents, render_view_host),
       update_rect_count_(0),
+      damage_buffer_call_count_(0),
       crash_observed_(false),
       focus_observed_(false),
       advance_focus_observed_(false),
       was_hidden_observed_(false),
       stop_observed_(false),
       reload_observed_(false),
-      waiting_for_update_rect_msg_with_size_(false),
-      last_update_rect_width_(-1),
-      last_update_rect_height_(-1) {
+      waiting_for_damage_buffer_with_size_(false),
+      last_damage_buffer_size_(gfx::Size()) {
   // Listen to visibility changes so that a test can wait for these changes.
   registrar_.Add(this,
                  NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
                  Source<WebContents>(web_contents));
 }
 
 TestBrowserPluginGuest::~TestBrowserPluginGuest() {
 }
 
 void TestBrowserPluginGuest::Observe(int type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   switch (type) {
     case NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED: {
       bool visible = *Details<bool>(details).ptr();
       if (!visible) {
         was_hidden_observed_ = true;
         if (was_hidden_message_loop_runner_)
           was_hidden_message_loop_runner_->Quit();
       }
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification type: " << type;
   }
 }
 
 void TestBrowserPluginGuest::SendMessageToEmbedder(IPC::Message* msg) {
   if (msg->type() == BrowserPluginMsg_UpdateRect::ID) {
-    PickleIterator iter(*msg);
-
-    int instance_id;
-    int message_id;
-    BrowserPluginMsg_UpdateRect_Params update_rect_params;
-
-    if (!IPC::ReadParam(msg, &iter, &instance_id) ||
-        !IPC::ReadParam(msg, &iter, &message_id) ||
-        !IPC::ReadParam(msg, &iter, &update_rect_params)) {
-      NOTREACHED() <<
-          "Cannot read BrowserPluginMsg_UpdateRect params from ipc message";
-    }
-    last_update_rect_width_ = update_rect_params.view_size.width();
-    last_update_rect_height_ = update_rect_params.view_size.height();
     update_rect_count_++;
-    if (waiting_for_update_rect_msg_with_size_ &&
-        expected_width_ == last_update_rect_width_ &&
-        expected_height_ == last_update_rect_height_) {
-      waiting_for_update_rect_msg_with_size_ = false;
-      if (send_message_loop_runner_)
-        send_message_loop_runner_->Quit();
-    } else if (!waiting_for_update_rect_msg_with_size_) {
-      if (send_message_loop_runner_)
-        send_message_loop_runner_->Quit();
-    }
+    if (send_message_loop_runner_)
+      send_message_loop_runner_->Quit();
   }
   BrowserPluginGuest::SendMessageToEmbedder(msg);
 }
 
 void TestBrowserPluginGuest::WaitForUpdateRectMsg() {
   // Check if we already got any UpdateRect message.
   if (update_rect_count_ > 0)
     return;
   send_message_loop_runner_ = new MessageLoopRunner();
   send_message_loop_runner_->Run();
 }
 
 void TestBrowserPluginGuest::ResetUpdateRectCount() {
   update_rect_count_ = 0;
 }
 
-void TestBrowserPluginGuest::WaitForUpdateRectMsgWithSize(int width,
-                                                          int height) {
-  if (update_rect_count_ > 0 &&
-      last_update_rect_width_ == width &&
-      last_update_rect_height_ == height) {
-    // We already saw this message.
+void TestBrowserPluginGuest::WaitForDamageBufferWithSize(
+    const gfx::Size& size) {
+  if (damage_buffer_call_count_ > 0 && last_damage_buffer_size_ == size)
     return;
-  }
-  waiting_for_update_rect_msg_with_size_ = true;
-  expected_width_ = width;
-  expected_height_ = height;
 
-  send_message_loop_runner_ = new MessageLoopRunner();
-  send_message_loop_runner_->Run();
+  expected_damage_buffer_size_ = size;
+  waiting_for_damage_buffer_with_size_ = true;
+  damage_buffer_message_loop_runner_ = new MessageLoopRunner();
+  damage_buffer_message_loop_runner_->Run();
 }
 
 void TestBrowserPluginGuest::RenderViewGone(base::TerminationStatus status) {
   crash_observed_ = true;
   LOG(INFO) << "Guest crashed";
   if (crash_message_loop_runner_)
     crash_message_loop_runner_->Quit();
   BrowserPluginGuest::RenderViewGone(status);
 }
 
@@ skipping 45 matching lines @@
   if (stop_observed_) {
     stop_observed_ = false;
     return;
   }
 
   stop_message_loop_runner_ = new MessageLoopRunner();
   stop_message_loop_runner_->Run();
   stop_observed_ = false;
 }
 
-
 void TestBrowserPluginGuest::SetFocus(bool focused) {
   focus_observed_ = true;
   if (focus_message_loop_runner_)
     focus_message_loop_runner_->Quit();
   BrowserPluginGuest::SetFocus(focused);
 }
 
 bool TestBrowserPluginGuest::ViewTakeFocus(bool reverse) {
   advance_focus_observed_ = true;
   if (advance_focus_message_loop_runner_)
     advance_focus_message_loop_runner_->Quit();
   return BrowserPluginGuest::ViewTakeFocus(reverse);
 }
 
 void TestBrowserPluginGuest::Reload() {
   reload_observed_ = true;
   if (reload_message_loop_runner_)
     reload_message_loop_runner_->Quit();
   BrowserPluginGuest::Reload();
 }
 
 void TestBrowserPluginGuest::Stop() {
   stop_observed_ = true;
   if (stop_message_loop_runner_)
     stop_message_loop_runner_->Quit();
   BrowserPluginGuest::Stop();
 }
 
+void TestBrowserPluginGuest::SetDamageBuffer(
+    TransportDIB* damage_buffer,
+#if defined(OS_WIN)
+    int damage_buffer_size,
+#endif
+    const gfx::Size& damage_view_size,
+    float scale_factor) {
+  ++damage_buffer_call_count_;
+  last_damage_buffer_size_ = damage_view_size;
+
+  if (waiting_for_damage_buffer_with_size_ &&
+      expected_damage_buffer_size_ == damage_view_size &&
+      damage_buffer_message_loop_runner_) {
+    damage_buffer_message_loop_runner_->Quit();
+    waiting_for_damage_buffer_with_size_ = false;
+  }
+
+  BrowserPluginGuest::SetDamageBuffer(
+      damage_buffer,
+#if defined(OS_WIN)
+      damage_buffer_size,
+#endif
+      damage_view_size,
+      scale_factor);
+}
+
 }  // namespace content