Revert of [devtools] Support different encodings for Page.CaptureScreenshot.

ui/snapshot/screenshot_grabber.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 "ui/snapshot/screenshot_grabber.h"
 
 #include <stddef.h>
 
 #include <climits>
 #include <string>
@@ skipping 25 matching lines @@
 // more than 1000 to prevent the conflict of filenames.
 const int kScreenshotMinimumIntervalInMS = 1000;
 
 using ShowNotificationCallback =
     base::Callback<void(ScreenshotGrabberObserver::Result screenshot_result,
                         const base::FilePath& screenshot_path)>;
 
 void SaveScreenshot(scoped_refptr<base::TaskRunner> ui_task_runner,
                     const ShowNotificationCallback& callback,
                     const base::FilePath& screenshot_path,
-                    scoped_refptr<base::RefCountedMemory> png_data,
+                    scoped_refptr<base::RefCountedBytes> png_data,
                     ScreenshotGrabberDelegate::FileResult result,
                     const base::FilePath& local_path) {
   DCHECK(!base::MessageLoopForUI::IsCurrent());
   DCHECK(!screenshot_path.empty());
 
   // Convert FileResult into ScreenshotGrabberObserver::Result.
   ScreenshotGrabberObserver::Result screenshot_result =
       ScreenshotGrabberObserver::SCREENSHOT_SUCCESS;
   switch (result) {
     case ScreenshotGrabberDelegate::FILE_SUCCESS:
       // Successfully got a local file to write to, write png data.
       DCHECK_GT(static_cast<int>(png_data->size()), 0);
       if (static_cast<size_t>(base::WriteFile(
-              local_path, reinterpret_cast<const char*>(png_data->front()),
+              local_path, reinterpret_cast<char*>(&(png_data->data()[0])),
               static_cast<int>(png_data->size()))) != png_data->size()) {
         LOG(ERROR) << "Failed to save to " << local_path.value();
         screenshot_result =
             ScreenshotGrabberObserver::SCREENSHOT_WRITE_FILE_FAILED;
       }
       break;
     case ScreenshotGrabberDelegate::FILE_CHECK_DIR_FAILED:
       screenshot_result =
           ScreenshotGrabberObserver::SCREENSHOT_CHECK_DIR_FAILED;
       break;
@@ skipping 90 matching lines @@
   // screen (i.e. non partial) screenshot. The only time is_partial can be
   // false, we will also have an identification string for the window.
   std::string window_identifier;
 #if defined(USE_AURA)
   aura::Window* aura_window = static_cast<aura::Window*>(window);
   is_partial = rect.size() != aura_window->bounds().size();
   window_identifier = aura_window->GetBoundsInScreen().ToString();
 
   cursor_hider_ = ScopedCursorHider::Create(aura_window->GetRootWindow());
 #endif
-  ui::GrabWindowSnapshotAsyncPNG(
+  ui::GrabWindowSnapshotAsync(
       window, rect, blocking_task_runner_,
       base::Bind(&ScreenshotGrabber::GrabWindowSnapshotAsyncCallback,
                  factory_.GetWeakPtr(), window_identifier, screenshot_path,
                  is_partial));
 }
 
 bool ScreenshotGrabber::CanTakeScreenshot() {
   return last_screenshot_timestamp_.is_null() ||
          base::TimeTicks::Now() - last_screenshot_timestamp_ >
              base::TimeDelta::FromMilliseconds(kScreenshotMinimumIntervalInMS);
@@ skipping 20 matching lines @@
 
 bool ScreenshotGrabber::HasObserver(
     const ScreenshotGrabberObserver* observer) const {
   return observers_.HasObserver(observer);
 }
 
 void ScreenshotGrabber::GrabWindowSnapshotAsyncCallback(
     const std::string& window_identifier,
     base::FilePath screenshot_path,
     bool is_partial,
-    scoped_refptr<base::RefCountedMemory> png_data) {
+    scoped_refptr<base::RefCountedBytes> png_data) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
   if (!png_data.get()) {
     if (is_partial) {
       LOG(ERROR) << "Failed to grab the window screenshot";
       NotifyScreenshotCompleted(
           ScreenshotGrabberObserver::SCREENSHOT_GRABWINDOW_PARTIAL_FAILED,
           screenshot_path);
     } else {
       LOG(ERROR) << "Failed to grab the window screenshot for "
                  << window_identifier;
       NotifyScreenshotCompleted(
           ScreenshotGrabberObserver::SCREENSHOT_GRABWINDOW_FULL_FAILED,
           screenshot_path);
     }
     return;
   }
 
   ShowNotificationCallback notification_callback(base::Bind(
       &ScreenshotGrabber::NotifyScreenshotCompleted, factory_.GetWeakPtr()));
   client_->PrepareFileAndRunOnBlockingPool(
       screenshot_path, blocking_task_runner_,
       base::Bind(&SaveScreenshot, base::ThreadTaskRunnerHandle::Get(),
                  notification_callback, screenshot_path, png_data));
 }
 
 }  // namespace ui