Migrate Telemetry from beginWindowSnapshotPNG to Page.captureScreenshot

content/browser/devtools/renderer_overrides_handler.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 "content/browser/devtools/renderer_overrides_handler.h"
 
 #include <map>
 #include <string>
 
 #include "base/barrier_closure.h"
@@ skipping 183 matching lines @@
 
   RenderWidgetHostViewPort* view_port =
       RenderWidgetHostViewPort::FromRWHV(host->GetView());
 
   gfx::Rect view_bounds = host->GetView()->GetViewBounds();
   gfx::Size snapshot_size = gfx::ToFlooredSize(
       gfx::ScaleSize(view_bounds.size(), scale));
 
   view_port->CopyFromCompositingSurface(
       view_bounds, snapshot_size,
-      base::Bind(&RendererOverridesHandler::ScreenshotCaptured,
+      base::Bind(&RendererOverridesHandler::ScreencastFrameCaptured,
                  weak_factory_.GetWeakPtr(),
-                 scoped_refptr<DevToolsProtocol::Command>(), format, quality,
-                 last_compositor_frame_metadata_),
+                 format, quality, last_compositor_frame_metadata_),
       SkBitmap::kARGB_8888_Config);
 }
 
 void RendererOverridesHandler::ParseCaptureParameters(
     DevToolsProtocol::Command* command,
     std::string* format,
     int* quality,
     double* scale) {
   *quality = kDefaultScreenshotQuality;
   *scale = 1;
   double max_width = -1;
   double max_height = -1;
   base::DictionaryValue* params = command->params();
   if (params) {
-    params->GetString(devtools::Page::captureScreenshot::kParamFormat,
+    params->GetString(devtools::Page::startScreencast::kParamFormat,
                       format);
-    params->GetInteger(devtools::Page::captureScreenshot::kParamQuality,
+    params->GetInteger(devtools::Page::startScreencast::kParamQuality,
                        quality);
-    params->GetDouble(devtools::Page::captureScreenshot::kParamMaxWidth,
+    params->GetDouble(devtools::Page::startScreencast::kParamMaxWidth,
                       &max_width);
-    params->GetDouble(devtools::Page::captureScreenshot::kParamMaxHeight,
+    params->GetDouble(devtools::Page::startScreencast::kParamMaxHeight,
                       &max_height);
   }
 
   RenderViewHost* host = agent_->GetRenderViewHost();
   CHECK(host->GetView());
   gfx::Rect view_bounds = host->GetView()->GetViewBounds();
   if (max_width > 0)
     *scale = std::min(*scale, max_width / view_bounds.width());
   if (max_height > 0)
     *scale = std::min(*scale, max_height / view_bounds.height());
@@ skipping 177 matching lines @@
       }
       return command->InvalidParamResponse(param);
     }
   }
   return command->InternalErrorResponse("No WebContents to navigate");
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageCaptureScreenshot(
     scoped_refptr<DevToolsProtocol::Command> command) {
-  RenderViewHost* host = agent_->GetRenderViewHost();
+  RenderViewHostImpl* host = static_cast<RenderViewHostImpl*>(
+      agent_->GetRenderViewHost());
   if (!host->GetView())
     return command->InternalErrorResponse("Unable to access the view");
 
-  std::string format;
-  int quality = kDefaultScreenshotQuality;
-  double scale = 1;
-  ParseCaptureParameters(command.get(), &format, &quality, &scale);
+  host->GetSnapshotFromBrowser(
+      base::Bind(&RendererOverridesHandler::ScreenshotCaptured,
+                 weak_factory_.GetWeakPtr(), command));
 
-  gfx::Rect view_bounds = host->GetView()->GetViewBounds();
-  gfx::Size snapshot_size = gfx::ToFlooredSize(
-      gfx::ScaleSize(view_bounds.size(), scale));
-
-  // Grab screen pixels if available for current platform.
-  // TODO(pfeldman): support format, scale and quality in ui::GrabViewSnapshot.
-  std::vector<unsigned char> png;
-  bool is_unscaled_png = scale == 1 && format == kPng;
-  if (is_unscaled_png && ui::GrabViewSnapshot(host->GetView()->GetNativeView(),
-                                              &png,
-                                              gfx::Rect(snapshot_size))) {
-    std::string base64_data;
-    base::Base64Encode(
-        base::StringPiece(reinterpret_cast<char*>(&*png.begin()), png.size()),
-        &base64_data);
-    base::DictionaryValue* result = new base::DictionaryValue();
-    result->SetString(
-        devtools::Page::captureScreenshot::kResponseData, base64_data);
-    return command->SuccessResponse(result);
-  }
-
-  // Fallback to copying from compositing surface.
-  RenderWidgetHostViewPort* view_port =
-      RenderWidgetHostViewPort::FromRWHV(host->GetView());
-
-  view_port->CopyFromCompositingSurface(
-      view_bounds, snapshot_size,
-      base::Bind(&RendererOverridesHandler::ScreenshotCaptured,
-                 weak_factory_.GetWeakPtr(), command, format, quality,
-                 last_compositor_frame_metadata_),
-      SkBitmap::kARGB_8888_Config);
   return command->AsyncResponsePromise();
 }
 
+void RendererOverridesHandler::ScreenshotCaptured(
+    scoped_refptr<DevToolsProtocol::Command> command,
+    const unsigned char* png_data,
+    size_t png_size) {
+  if (!png_data || !png_size) {
+    SendAsyncResponse(
+        command->InternalErrorResponse("Unable to capture screenshot"));
+    return;
+  }
+
+  std::string base_64_data;
+  base::Base64Encode(
+      base::StringPiece(reinterpret_cast<const char*>(png_data), png_size),
+      &base_64_data);
+
+  base::DictionaryValue* response = new base::DictionaryValue();
+  response->SetString(devtools::Page::screencastFrame::kParamData,
+                      base_64_data);
+
+  SendAsyncResponse(command->SuccessResponse(response));
+}
+
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageCanScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* result = new base::DictionaryValue();
 #if defined(OS_ANDROID)
   result->SetBoolean(devtools::kResult, true);
 #else
   result->SetBoolean(devtools::kResult, false);
 #endif  // defined(OS_ANDROID)
   return command->SuccessResponse(result);
@@ skipping 13 matching lines @@
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStopScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   last_frame_time_ = base::TimeTicks();
   screencast_command_ = NULL;
   return command->SuccessResponse(NULL);
 }
 
-void RendererOverridesHandler::ScreenshotCaptured(
-    scoped_refptr<DevToolsProtocol::Command> command,
+void RendererOverridesHandler::ScreencastFrameCaptured(
     const std::string& format,
     int quality,
     const cc::CompositorFrameMetadata& metadata,
     bool success,
     const SkBitmap& bitmap) {
   if (!success) {
-    if (command) {
-      SendAsyncResponse(
-          command->InternalErrorResponse("Unable to capture screenshot"));
-    } else if (capture_retry_count_) {
+    if (capture_retry_count_) {
       --capture_retry_count_;
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&RendererOverridesHandler::InnerSwapCompositorFrame,
                      weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kFrameRateThresholdMs));
     }
     return;
   }
 
@@ skipping 12 matching lines @@
         reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)),
         gfx::JPEGCodec::FORMAT_SkBitmap,
         bitmap.width(),
         bitmap.height(),
         bitmap.width() * bitmap.bytesPerPixel(),
         quality, &data);
   } else {
     encoded = false;
   }
 
-  if (!encoded) {
-    if (command) {
-      SendAsyncResponse(
-          command->InternalErrorResponse("Unable to encode screenshot"));
-    }
+  if (!encoded)
     return;
-  }
 
   std::string base_64_data;
   base::Base64Encode(
       base::StringPiece(reinterpret_cast<char*>(&data[0]), data.size()),
       &base_64_data);
 
   base::DictionaryValue* response = new base::DictionaryValue();
   response->SetString(devtools::Page::screencastFrame::kParamData,
                       base_64_data);
 
@@ skipping 25 matching lines @@
                         metadata.root_scroll_offset.x());
     viewport->SetDouble(devtools::DOM::Rect::kParamY,
                         metadata.root_scroll_offset.y());
     viewport->SetDouble(devtools::DOM::Rect::kParamWidth,
                         metadata.viewport_size.width());
     viewport->SetDouble(devtools::DOM::Rect::kParamHeight,
                         metadata.viewport_size.height());
     response_metadata->Set(
         devtools::Page::ScreencastFrameMetadata::kParamViewport, viewport);
 
-    if (command) {
-      response->Set(devtools::Page::captureScreenshot::kResponseMetadata,
-                    response_metadata);
-    } else {
-      response->Set(devtools::Page::screencastFrame::kParamMetadata,
-                    response_metadata);
-    }
+    response->Set(devtools::Page::screencastFrame::kParamMetadata,
+                  response_metadata);
   }
 
-  if (command) {
-    SendAsyncResponse(command->SuccessResponse(response));
-  } else {
-    SendNotification(devtools::Page::screencastFrame::kName, response);
-  }
+  SendNotification(devtools::Page::screencastFrame::kName, response);
 }
 
 // Quota and Usage ------------------------------------------
 
 namespace {
 
 typedef base::Callback<void(scoped_ptr<base::DictionaryValue>)>
     ResponseCallback;
 
 void QueryUsageAndQuotaCompletedOnIOThread(
@@ skipping 350 matching lines @@
       return NULL;
     }
     event.data.pinchUpdate.scale = static_cast<float>(scale);
   }
 
   host->ForwardGestureEvent(event);
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content