[devtools] Support different encodings for Page.CaptureScreenshot.

chrome/browser/chromeos/login/screenshot_testing/screenshot_tester.cc

 // Copyright 2014 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 "chrome/browser/chromeos/login/screenshot_testing/screenshot_tester.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "ash/shell.h"
@@ skipping 169 matching lines @@
                                  PNGFile png_data) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!png_data.get()) {
     LOG(ERROR) << "There is no png data";
     return false;
   }
   if (!base::CreateDirectory(image_path.DirName())) {
     LOG(ERROR) << "Can't create directory" << image_path.DirName().value();
     return false;
   }
-  if (static_cast<size_t>(
-          base::WriteFile(image_path,
-                          reinterpret_cast<char*>(&(png_data->data()[0])),
-                          png_data->size())) != png_data->size()) {
+  if (static_cast<size_t>(base::WriteFile(
+          image_path, reinterpret_cast<const char*>(png_data->front()),
+          png_data->size())) != png_data->size()) {
     LOG(ERROR) << "Can't save screenshot " << image_path.BaseName().value()
                << ".";
     return false;
   }
   VLOG(0) << "Screenshot " << image_path.BaseName().value() << " saved to "
           << image_path.DirName().value() << ".";
   return true;
 }
 
-void ScreenshotTester::ReturnScreenshot(const PNGFile& screenshot,
-                                        PNGFile png_data) {
+void ScreenshotTester::ReturnScreenshot(PNGFile* screenshot, PNGFile png_data) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  screenshot->data() = png_data->data();
+  *screenshot = png_data;
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE, run_loop_quitter_);
 }
 
 ScreenshotTester::PNGFile ScreenshotTester::TakeScreenshot() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   aura::Window* primary_window = ash::Shell::GetPrimaryRootWindow();
   gfx::Rect rect = primary_window->bounds();
-  PNGFile screenshot = new base::RefCountedBytes;
-  ui::GrabWindowSnapshotAsync(primary_window,
-                              rect,
-                              content::BrowserThread::GetBlockingPool(),
-                              base::Bind(&ScreenshotTester::ReturnScreenshot,
-                                         weak_factory_.GetWeakPtr(),
-                                         screenshot));
+  PNGFile screenshot;
+  ui::GrabWindowSnapshotAsyncPNG(
+      primary_window, rect, content::BrowserThread::GetBlockingPool(),
+      base::Bind(&ScreenshotTester::ReturnScreenshot,
+                 weak_factory_.GetWeakPtr(), &screenshot));
   base::RunLoop run_loop;
   run_loop_quitter_ = run_loop.QuitClosure();
   run_loop.Run();
   return screenshot;
 }
 
 ScreenshotTester::PNGFile ScreenshotTester::LoadGoldenScreenshot(
     base::FilePath image_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!base::PathExists(image_path)) {
     LOG(WARNING) << "Can't find a golden screenshot for this test";
     return 0;
   }
 
   int64_t golden_screenshot_size;
   base::GetFileSize(image_path, &golden_screenshot_size);
 
   if (golden_screenshot_size == -1) {
     CHECK(false) << "Can't get golden screenshot size";
   }
-  PNGFile png_data = new base::RefCountedBytes;
+  scoped_refptr<base::RefCountedBytes> png_data = new base::RefCountedBytes;
   png_data->data().resize(golden_screenshot_size);
   base::ReadFile(image_path,
                  reinterpret_cast<char*>(&(png_data->data()[0])),
                  golden_screenshot_size);
 
   return png_data;
 }
 
 SkBitmap ScreenshotTester::ProcessImageForComparison(const PNGFile& image) {
   CHECK(image.get());
   SkBitmap current_bitmap;
-  gfx::PNGCodec::Decode(reinterpret_cast<unsigned char*>(&(image->data()[0])),
-                        image->data().size(),
-                        &current_bitmap);
+  gfx::PNGCodec::Decode(image->front(), image->size(), &current_bitmap);
   EraseIgnoredAreas(current_bitmap);
   return current_bitmap;
 }
 
 ScreenshotTester::Result ScreenshotTester::CompareScreenshots(
     const PNGFile& model,
     const PNGFile& sample) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   SkBitmap model_bitmap;
@@ skipping 54 matching lines @@
   Result testing_result;
 
   testing_result.screenshots_match =
       (result.result >= kPrecision &&
        result.maxRedDiff <= kMaxAllowedColorDifference &&
        result.maxGreenDiff <= kMaxAllowedColorDifference &&
        result.maxBlueDiff <= kMaxAllowedColorDifference);
 
   testing_result.similarity = result.result;
 
-  testing_result.diff_image = new base::RefCountedBytes;
-  testing_result.diff_image->data().resize(result.rgbDiffBitmap.getSize());
-  CHECK(gfx::PNGCodec::EncodeBGRASkBitmap(
-      result.rgbDiffBitmap, false, &testing_result.diff_image->data()))
+  scoped_refptr<base::RefCountedBytes> diff_image(new base::RefCountedBytes);
+  diff_image->data().resize(result.rgbDiffBitmap.getSize());
+  CHECK(gfx::PNGCodec::EncodeBGRASkBitmap(result.rgbDiffBitmap, false,
+                                          &diff_image->data()))
       << "Could not encode difference to PNG";
+  testing_result.diff_image = diff_image;
 
   return testing_result;
 }
 
 ScreenshotTester::Result ScreenshotTester::CompareScreenshotsPerceptually(
     SkBitmap model_bitmap,
     SkBitmap sample_bitmap) {
   SkPMetric differ;
   SkImageDiffer::BitmapsToCreate diff_parameters;
   SkImageDiffer::Result result;
 
   differ.diff(&model_bitmap, &sample_bitmap, diff_parameters, &result);
 
   ScreenshotTester::Result testing_result;
   testing_result.similarity = result.result;
   testing_result.screenshots_match =
       (result.result == SkImageDiffer::RESULT_CORRECT);
 
   return testing_result;
 }
 
 }  // namespace chromeos