[devtools] Support different encodings for Page.CaptureScreenshot.

ui/snapshot/snapshot_aura_unittest.cc

 // Copyright (c) 2013 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 "ui/snapshot/snapshot.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 123 matching lines @@
     delegate_.reset(new TestPaintingWindowDelegate(window_bounds.size()));
     test_window_.reset(aura::test::CreateTestWindowWithDelegate(
         delegate_.get(), 0, window_bounds, root_window()));
   }
 
   gfx::Image GrabSnapshotForTestWindow() {
     gfx::Rect source_rect(test_window_->bounds().size());
     aura::Window::ConvertRectToTarget(
         test_window(), root_window(), &source_rect);
 
-    scoped_refptr<base::TestSimpleTaskRunner> task_runner(
-        new base::TestSimpleTaskRunner());
     scoped_refptr<SnapshotHolder> holder(new SnapshotHolder);
     ui::GrabWindowSnapshotAsync(
-        root_window(),
-        source_rect,
-        task_runner,
+        root_window(), source_rect,
         base::Bind(&SnapshotHolder::SnapshotCallback, holder));
 
-    // Wait for copy response.
-    WaitForDraw();
-    // Run internal snapshot callback to scale/rotate response image.
-    task_runner->RunUntilIdle();
-    // Run SnapshotHolder callback.
-    helper_->RunAllPendingInMessageLoop();
-
-    if (holder->completed())
-      return holder->image();
-
-    // Callback never called.
-    NOTREACHED();
-    return gfx::Image();
+    holder->WaitForSnapshot();
+    DCHECK(holder->completed());
+    return holder->image();
   }
 
  private:
   class SnapshotHolder : public base::RefCountedThreadSafe<SnapshotHolder> {
    public:
     SnapshotHolder() : completed_(false) {}
 
-    void SnapshotCallback(scoped_refptr<base::RefCountedBytes> png_data) {
+    void SnapshotCallback(const gfx::Image& image) {
       DCHECK(!completed_);
-      image_ = gfx::Image::CreateFrom1xPNGBytes(&(png_data->data()[0]),
-                                                png_data->size());
+      image_ = image;
       completed_ = true;
+      run_loop_.Quit();
     }
+    void WaitForSnapshot() { run_loop_.Run(); }
     bool completed() const {
       return completed_;
     };
     const gfx::Image& image() const { return image_; }
 
    private:
     friend class base::RefCountedThreadSafe<SnapshotHolder>;
 
     virtual ~SnapshotHolder() {}
 
+    base::RunLoop run_loop_;
     gfx::Image image_;
     bool completed_;
   };
 
   std::unique_ptr<aura::test::AuraTestHelper> helper_;
   std::unique_ptr<aura::Window> test_window_;
   std::unique_ptr<TestPaintingWindowDelegate> delegate_;
   std::vector<unsigned char> png_representation_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotAuraTest);
@@ skipping 25 matching lines @@
   gfx::Rect test_bounds(100, 100, 300, 200);
   SetupTestWindow(test_bounds);
   WaitForDraw();
 
   gfx::Image snapshot = GrabSnapshotForTestWindow();
   EXPECT_EQ(test_bounds.size().ToString(), snapshot.Size().ToString());
   EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
 }
 
 TEST_F(SnapshotAuraTest, UIScale) {
-  const float kUIScale = 1.25f;
+  const float kUIScale = 0.5f;
   test_screen()->SetUIScale(kUIScale);
 
   gfx::Rect test_bounds(100, 100, 300, 200);
   SetupTestWindow(test_bounds);
   WaitForDraw();
 
   // Snapshot always captures the physical pixels.
   gfx::SizeF snapshot_size(test_bounds.size());
+  snapshot_size.Scale(1 / kUIScale);
 
   gfx::Image snapshot = GrabSnapshotForTestWindow();
   EXPECT_EQ(gfx::ToRoundedSize(snapshot_size).ToString(),
             snapshot.Size().ToString());
-  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
+  EXPECT_EQ(0u, GetFailedPixelsCountWithScaleFactor(snapshot, 1 / kUIScale));
 }
 
 TEST_F(SnapshotAuraTest, DeviceScaleFactor) {
   test_screen()->SetDeviceScaleFactor(2.0f);
 
   gfx::Rect test_bounds(100, 100, 150, 100);
   SetupTestWindow(test_bounds);
   WaitForDraw();
 
   // Snapshot always captures the physical pixels.
   gfx::SizeF snapshot_size(test_bounds.size());
   snapshot_size.Scale(2.0f);
 
   gfx::Image snapshot = GrabSnapshotForTestWindow();
   EXPECT_EQ(gfx::ToRoundedSize(snapshot_size).ToString(),
             snapshot.Size().ToString());
   EXPECT_EQ(0u, GetFailedPixelsCountWithScaleFactor(snapshot, 2));
 }
 
 TEST_F(SnapshotAuraTest, RotateAndUIScale) {
-  const float kUIScale = 1.25f;
+  const float kUIScale = 0.5f;
   test_screen()->SetUIScale(kUIScale);
   test_screen()->SetDisplayRotation(display::Display::ROTATE_90);
 
   gfx::Rect test_bounds(100, 100, 300, 200);
   SetupTestWindow(test_bounds);
   WaitForDraw();
 
   // Snapshot always captures the physical pixels.
   gfx::SizeF snapshot_size(test_bounds.size());
+  snapshot_size.Scale(1 / kUIScale);
 
   gfx::Image snapshot = GrabSnapshotForTestWindow();
   EXPECT_EQ(gfx::ToRoundedSize(snapshot_size).ToString(),
             snapshot.Size().ToString());
-  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
+  EXPECT_EQ(0u, GetFailedPixelsCountWithScaleFactor(snapshot, 1 / kUIScale));
 }
 
 TEST_F(SnapshotAuraTest, RotateAndUIScaleAndScaleFactor) {
   test_screen()->SetDeviceScaleFactor(2.0f);
-  const float kUIScale = 1.25f;
+  const float kUIScale = 0.5f;
   test_screen()->SetUIScale(kUIScale);
   test_screen()->SetDisplayRotation(display::Display::ROTATE_90);
 
   gfx::Rect test_bounds(20, 30, 150, 100);
   SetupTestWindow(test_bounds);
   WaitForDraw();
 
   // Snapshot always captures the physical pixels.
   gfx::SizeF snapshot_size(test_bounds.size());
-  snapshot_size.Scale(2.0f);
+  snapshot_size.Scale(2.0f / kUIScale);
 
   gfx::Image snapshot = GrabSnapshotForTestWindow();
   EXPECT_EQ(gfx::ToRoundedSize(snapshot_size).ToString(),
             snapshot.Size().ToString());
-  EXPECT_EQ(0u, GetFailedPixelsCountWithScaleFactor(snapshot, 2));
+  EXPECT_EQ(0u, GetFailedPixelsCountWithScaleFactor(snapshot, 2 / kUIScale));
 }
 
 }  // namespace ui