Resubmit 114881, but without a bad dependency on base.

Original code review: http://codereview.chromium.org/8954008

BUG=none
TEST=ui_tests
Review URL: http://codereview.chromium.org/8982004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@115053 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 128 insertions, 26 deletions

diff --git a/ppapi/tests/test_fullscreen.cc b/ppapi/tests/test_fullscreen.cc
index 77320e2..c531c02 100644
--- a/ppapi/tests/test_fullscreen.cc
+++ b/ppapi/tests/test_fullscreen.cc
@@ -10,6 +10,7 @@
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/ppb_fullscreen.h"
+#include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
@@ -21,12 +22,30 @@ REGISTER_TEST_CASE(Fullscreen);
 
 namespace {
 
+const ColorPremul kOpaqueWhite = { 0xFF, 0xFF, 0xFF, 0xFF };
+const ColorPremul kSheerRed = { 0x88, 0x88, 0x00, 0x00 };
+const ColorPremul kSheerBlue = { 0x88, 0x00, 0x00, 0x88 };
+const ColorPremul kOpaqueYellow = { 0xFF, 0xFF, 0xFF, 0x00 };
+const int kBytesPerPixel = sizeof(uint32_t);  // 4 bytes for BGRA or RGBA.
+
+uint32_t FormatColor(PP_ImageDataFormat format, ColorPremul color) {
+  if (format == PP_IMAGEDATAFORMAT_BGRA_PREMUL)
+    return (color.A << 24) | (color.R << 16) | (color.G << 8) | (color.B);
+  else if (format == PP_IMAGEDATAFORMAT_RGBA_PREMUL)
+    return (color.A << 24) | (color.B << 16) | (color.G << 8) | (color.R);
+  else
+    return 0;
+}
+
 bool HasMidScreen(const pp::Rect& position, const pp::Size& screen_size) {
   static int32_t mid_x = screen_size.width() / 2;
   static int32_t mid_y = screen_size.height() / 2;
   return (position.Contains(mid_x, mid_y));
 }
 
+void FlushCallback(void* user_data, int32_t result) {
+}
+
 }  // namespace
 
 TestFullscreen::TestFullscreen(TestingInstance* instance)
@@ -36,8 +55,6 @@ TestFullscreen::TestFullscreen(TestingInstance* instance)
       fullscreen_pending_(false),
       normal_pending_(false),
       saw_first_fullscreen_didchangeview(false),
-      graphics2d_fullscreen_(instance, pp::Size(10, 10), false),
-      graphics2d_normal_(instance, pp::Size(15, 15), false),
       set_fullscreen_true_callback_(instance->pp_instance()),
       fullscreen_callback_(instance->pp_instance()),
       normal_callback_(instance->pp_instance()) {
@@ -45,8 +62,15 @@ TestFullscreen::TestFullscreen(TestingInstance* instance)
 }
 
 bool TestFullscreen::Init() {
-  if (graphics2d_fullscreen_.is_null() && graphics2d_normal_.is_null())
+  if (screen_size_.IsEmpty()) {
+    instance_->AppendError("Failed to initialize screen_size_");
     return false;
+  }
+  graphics2d_ = pp::Graphics2D(instance_, screen_size_, true);
+  if (!instance_->BindGraphics(graphics2d_)) {
+    instance_->AppendError("Failed to initialize graphics2d_");
+    return false;
+  }
   return InitTestingInterface();
 }
 
@@ -65,6 +89,9 @@ std::string TestFullscreen::Error() {
   return last_error;
 }
 
+// TODO(polina): consider adding custom logic to JS for this test to
+// get screen.width and screen.height and postMessage those to this code,
+// so the dimensions can be checked exactly.
 std::string TestFullscreen::TestGetScreenSize() {
   if (screen_size_.width() < 320 || screen_size_.width() > 2560)
     return ReportError("screen_size.width()", screen_size_.width());
@@ -82,11 +109,10 @@ std::string TestFullscreen::TestNormalToFullscreenToNormal() {
   // This is only allowed within a context of a user gesture (e.g. mouse click).
   if (screen_mode_.SetFullscreen(true))
     return ReportError("SetFullscreen(true) outside of user gesture", true);
+  // Trigger another call to SetFullscreen(true) from HandleInputEvent().
   // The transition is asynchronous and ends at the next DidChangeView().
-  // No graphics devices can be bound while in transition.
   instance_->RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
   SimulateUserGesture();
-  // HandleInputEvent() will call SetFullscreen(true).
   // DidChangeView() will call the callback once in fullscreen mode.
   fullscreen_callback_.WaitForResult();
   if (GotError())
@@ -95,8 +121,6 @@ std::string TestFullscreen::TestNormalToFullscreenToNormal() {
     return "fullscreen_pending_ has not been reset";
   if (!screen_mode_.IsFullscreen())
     return ReportError("IsFullscreen() in fullscreen", false);
-  if (!instance_->BindGraphics(graphics2d_fullscreen_))
-    return ReportError("BindGraphics() in fullscreen", false);
 
   // 2. Stay in fullscreen. No change.
   if (screen_mode_.SetFullscreen(true))
@@ -115,18 +139,17 @@ std::string TestFullscreen::TestNormalToFullscreenToNormal() {
     return ReportError("SetFullscreen(false) in normal pending", true);
   if (screen_mode_.SetFullscreen(true))
     return ReportError("SetFullscreen(true) in normal pending", true);
-  if (instance_->BindGraphics(graphics2d_normal_))
-    return ReportError("BindGraphics() in normal transition", true);
   if (!screen_mode_.IsFullscreen())
     return ReportError("IsFullscreen() in normal transition", false);
+  // No graphics devices can be bound while in transition.
+  if (instance_->BindGraphics(graphics2d_))
+    return ReportError("BindGraphics() in normal transition", true);
   // DidChangeView() will call the callback once out of fullscreen mode.
   normal_callback_.WaitForResult();
   if (normal_pending_)
     return "normal_pending_ has not been reset";
   if (screen_mode_.IsFullscreen())
     return ReportError("IsFullscreen() in normal", true);
-  if (!instance_->BindGraphics(graphics2d_fullscreen_))
-    return ReportError("BindGraphics() in normal", false);
 
   // 4. Stay in normal. No change.
   if (screen_mode_.SetFullscreen(false))
@@ -163,6 +186,22 @@ void TestFullscreen::FailFullscreenTest(const std::string& error) {
   pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_);
 }
 
+void TestFullscreen::FailNormalTest(const std::string& error) {
+  normal_pending_ = false;
+  error_ = error;
+  pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_);
+}
+
+void TestFullscreen::PassFullscreenTest() {
+  fullscreen_pending_ = false;
+  pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_);
+}
+
+void TestFullscreen::PassNormalTest() {
+  normal_pending_ = false;
+  pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_);
+}
+
 // Transition to fullscreen can only happen when processing a user gesture.
 bool TestFullscreen::HandleInputEvent(const pp::InputEvent& event) {
   // We only let mouse events through and only mouse clicks count.
@@ -171,6 +210,11 @@ bool TestFullscreen::HandleInputEvent(const pp::InputEvent& event) {
     return false;
   // We got the gesture. No need to handle any more events.
   instance_->ClearInputEventRequest(PP_INPUTEVENT_CLASS_MOUSE);
+  if (screen_mode_.IsFullscreen()) {
+    FailFullscreenTest(
+        ReportError("IsFullscreen() before fullscreen transition", true));
+    return false;
+  }
   fullscreen_pending_ = true;
   if (!screen_mode_.SetFullscreen(true)) {
     FailFullscreenTest(ReportError("SetFullscreen(true) in normal", false));
@@ -186,44 +230,89 @@ bool TestFullscreen::HandleInputEvent(const pp::InputEvent& event) {
     FailFullscreenTest(
         ReportError("SetFullscreen(false) in fullscreen pending", true));
   }
-  // No graphics devices can be bound while in transition.
-  if (instance_->BindGraphics(graphics2d_fullscreen_)) {
+  if (screen_mode_.IsFullscreen()) {
     FailFullscreenTest(
-        ReportError("BindGraphics() in fullscreen transition", true));
+        ReportError("IsFullscreen() in fullscreen transition", true));
     return false;
   }
-  if (screen_mode_.IsFullscreen()) {
+  // No graphics devices can be bound while in transition.
+  if (instance_->BindGraphics(graphics2d_)) {
     FailFullscreenTest(
-        ReportError("IsFullscreen() in fullscreen transtion", true));
+        ReportError("BindGraphics() in fullscreen transition", true));
     return false;
   }
   // DidChangeView() will complete the transition to fullscreen.
   return false;
 }
 
+bool TestFullscreen::PaintPlugin(pp::Size size, ColorPremul color) {
+  PP_ImageDataFormat image_format = pp::ImageData::GetNativeImageDataFormat();
+  uint32_t pixel_color = FormatColor(image_format, color);
+  if (pixel_color == 0)
+    return false;
+  pp::Point origin(0, 0);
+
+  pp::ImageData image(instance_, image_format, size, false);
+  if (image.is_null())
+    return false;
+  uint32_t* pixels = static_cast<uint32_t*>(image.data());
+  int num_pixels = image.stride() / kBytesPerPixel * image.size().height();
+  for (int i = 0; i < num_pixels; i++)
+    pixels[i] = pixel_color;
+  graphics2d_.PaintImageData(image, origin);
+  pp::CompletionCallback cc(FlushCallback, NULL);
+  if (graphics2d_.Flush(cc) != PP_OK_COMPLETIONPENDING)
+    return false;
+
+  // Confirm that painting was successful.
+  pp::ImageData readback(instance_, image_format, graphics2d_.size(), false);
+  if (readback.is_null())
+    return false;
+  if (PP_TRUE != testing_interface_->ReadImageData(graphics2d_.pp_resource(),
+                                                   readback.pp_resource(),
+                                                   &origin.pp_point()))
+    return false;
+  bool error = false;
+  for (int y = 0; y < size.height() && !error; y++) {
+    for (int x = 0; x < size.width() && !error; x++) {
+      uint32_t* readback_color = readback.GetAddr32(pp::Point(x, y));
+      if (pixel_color != *readback_color)
+        return false;
+    }
+  }
+  return true;
+}
+
 // Transitions to/from fullscreen is asynchornous ending at DidChangeView.
 // When going to fullscreen, two DidChangeView calls are generated:
 // one for moving the plugin to the middle of window and one for stretching
 // the window and placing the plugin in the middle of the screen.
+// This is not something we advertise to users and not something they should
+// rely on. But the test checks for these, so we know when the underlying
+// implementation changes.
+//
 // WebKit does not change the plugin size, but Pepper does explicitly set
 // it to screen width and height when SetFullscreen(true) is called and
 // resets it back when ViewChanged is received indicating that we exited
 // fullscreen.
+//
 // NOTE: The number of DidChangeView calls for <object> might be different.
 void TestFullscreen::DidChangeView(const pp::Rect& position,
                                    const pp::Rect& clip) {
-  if (normal_position_.IsEmpty())
+  if (normal_position_.IsEmpty()) {
     normal_position_ = position;
+    if (!PaintPlugin(position.size(), kSheerRed))
+      error_ = "Failed to initialize plugin image";
+  }
 
   if (fullscreen_pending_ && !saw_first_fullscreen_didchangeview) {
     saw_first_fullscreen_didchangeview = true;
     if (screen_mode_.IsFullscreen())
       FailFullscreenTest("DidChangeView1 is in fullscreen");
-    if (position.size() != screen_size_)
+    else if (position.size() != screen_size_)
       FailFullscreenTest("DidChangeView1 does not have screen size");
     // Wait for the 2nd DidChangeView.
   } else if (fullscreen_pending_) {
-    fullscreen_pending_ = false;
     saw_first_fullscreen_didchangeview = false;
     if (!screen_mode_.IsFullscreen())
       FailFullscreenTest("DidChangeView2 is not in fullscreen");
@@ -233,14 +322,23 @@ void TestFullscreen::DidChangeView(const pp::Rect& position,
       FailFullscreenTest("DidChangeView2 does not have screen size");
     // NOTE: we cannot reliably test for clip size being equal to the screen
     // because it might be affected by JS console, info bars, etc.
+    else if (!instance_->BindGraphics(graphics2d_))
+      FailFullscreenTest("Failed to BindGraphics() in fullscreen");
+    else if (!PaintPlugin(position.size(), kOpaqueYellow))
+      FailFullscreenTest("Failed to paint plugin image in fullscreen");
     else
-      pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_);
+      PassFullscreenTest();
   } else if (normal_pending_) {
     normal_pending_ = false;
     if (screen_mode_.IsFullscreen())
-      error_ = "DidChangeview is in fullscreen";
+      FailNormalTest("DidChangeview is in fullscreen");
     else if (position != normal_position_)
-      error_ = "DidChangeView position is not normal";
-    pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_);
+      FailNormalTest("DidChangeView position is not normal");
+    else if (!instance_->BindGraphics(graphics2d_))
+      FailNormalTest("Failed to BindGraphics() in normal");
+    else if (!PaintPlugin(position.size(), kSheerBlue))
+      FailNormalTest("Failed to paint plugin image in normal");
+    else
+      PassNormalTest();
   }
 }
diff --git a/ppapi/tests/test_fullscreen.h b/ppapi/tests/test_fullscreen.h
index f326bc9..220b7e9 100644
--- a/ppapi/tests/test_fullscreen.h
+++ b/ppapi/tests/test_fullscreen.h
@@ -18,6 +18,8 @@ namespace pp {
 class InputEvent;
 }  // namespace pp
 
+struct ColorPremul { uint32_t A, R, G, B; };  // Use premultipled Alpha.
+
 class TestFullscreen : public TestCase {
  public:
   explicit TestFullscreen(TestingInstance* instance);
@@ -33,8 +35,11 @@ class TestFullscreen : public TestCase {
   std::string TestNormalToFullscreenToNormal();
 
   void SimulateUserGesture();
-
   void FailFullscreenTest(const std::string& error);
+  void FailNormalTest(const std::string& error);
+  void PassFullscreenTest();
+  void PassNormalTest();
+  bool PaintPlugin(pp::Size size, ColorPremul color);
 
   bool GotError();
   std::string Error();
@@ -48,8 +53,7 @@ class TestFullscreen : public TestCase {
   bool fullscreen_pending_;
   bool normal_pending_;
   bool saw_first_fullscreen_didchangeview;
-  pp::Graphics2D graphics2d_fullscreen_;
-  pp::Graphics2D graphics2d_normal_;
+  pp::Graphics2D graphics2d_;
   TestCompletionCallback set_fullscreen_true_callback_;
   TestCompletionCallback fullscreen_callback_;
   TestCompletionCallback normal_callback_;