[DevTools] Make generated protocol structs wrappers around DictionaryValue

content/browser/devtools/protocol/page_handler.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 "content/browser/devtools/protocol/page_handler.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 105 matching lines @@
 
 void PageHandler::OnVisibilityChanged(bool visible) {
   if (!screencast_enabled_)
     return;
   NotifyScreencastVisibility(visible);
 }
 
 void PageHandler::DidAttachInterstitialPage() {
   if (!enabled_)
     return;
-  InterstitialShownParams params;
-  client_->InterstitialShown(params);
+  client_->InterstitialShown(nullptr);
 }
 
 void PageHandler::DidDetachInterstitialPage() {
   if (!enabled_)
     return;
-  InterstitialHiddenParams params;
-  client_->InterstitialHidden(params);
+  client_->InterstitialHidden(nullptr);
 }
 
 Response PageHandler::Enable() {
   enabled_ = true;
   return Response::FallThrough();
 }
 
 Response PageHandler::Disable() {
   enabled_ = false;
   touch_emulation_enabled_ = false;
@@ skipping 34 matching lines @@
   if (!web_contents)
     return Response::InternalError("No WebContents to navigate");
 
   web_contents->GetController()
       .LoadURL(gurl, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   return Response::FallThrough();
 }
 
 Response PageHandler::GetNavigationHistory(
     int* current_index,
-    std::vector<NavigationEntry>* entries) {
+    ListBuilder<NavigationEntry>* entries) {
   if (!host_)
     return Response::InternalError("Could not connect to view");
 
   WebContents* web_contents = WebContents::FromRenderViewHost(host_);
   if (!web_contents)
     return Response::InternalError("No WebContents to navigate");
 
   NavigationController& controller = web_contents->GetController();
   *current_index = controller.GetCurrentEntryIndex();
   for (int i = 0; i != controller.GetEntryCount(); ++i) {
-    NavigationEntry entry;
-    entry.set_id(controller.GetEntryAtIndex(i)->GetUniqueID());
-    entry.set_url(controller.GetEntryAtIndex(i)->GetURL().spec());
-    entry.set_title(
+    scoped_ptr<NavigationEntry> entry;

[dgozman, 2014/10/17 10:51:57]

I think, default constructor of scoped_ptr will have nullptr inside. Did you
test this?

[vkuzkokov, 2014/10/17 11:41:26]

Not every method.

+    entry->set_id(controller.GetEntryAtIndex(i)->GetUniqueID());
+    entry->set_url(controller.GetEntryAtIndex(i)->GetURL().spec());
+    entry->set_title(
         base::UTF16ToUTF8(controller.GetEntryAtIndex(i)->GetTitle()));
-    entries->push_back(entry);
+    entries->push_back(entry.Pass());
   }
   return Response::OK();
 }
 
 Response PageHandler::NavigateToHistoryEntry(int entry_id) {
   if (!host_)
     return Response::InternalError("Could not connect to view");
 
   WebContents* web_contents = WebContents::FromRenderViewHost(host_);
   if (!web_contents)
@@ skipping 192 matching lines @@
   host_->SetTouchEventEmulationEnabled(enabled);
   WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
       WebContents::FromRenderViewHost(host_));
   if (web_contents)
     web_contents->SetForceDisableOverscrollContent(enabled);
 }
 
 void PageHandler::NotifyScreencastVisibility(bool visible) {
   if (visible)
     capture_retry_count_ = kCaptureRetryLimit;
-  ScreencastVisibilityChangedParams params;
-  params.set_visible(visible);
-  client_->ScreencastVisibilityChanged(params);
+  scoped_ptr<ScreencastVisibilityChangedParams> params;
+  params->set_visible(visible);
+  client_->ScreencastVisibilityChanged(params.Pass());
 }
 
 void PageHandler::InnerSwapCompositorFrame() {
   if ((base::TimeTicks::Now() - last_frame_time_).InMilliseconds() <
           kFrameRateThresholdMs) {
     return;
   }
 
   if (!host_ || !host_->GetView())
     return;
@@ skipping 85 matching lines @@
   }
 
   if (!encoded)
     return;
 
   std::string base_64_data;
   base::Base64Encode(
       base::StringPiece(reinterpret_cast<char*>(&data[0]), data.size()),
       &base_64_data);
 
-  ScreencastFrameMetadata param_metadata;
+  scoped_ptr<ScreencastFrameMetadata> param_metadata;
   // Consider metadata empty in case it has no device scale factor.
   if (metadata.device_scale_factor != 0 && host_) {
     RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
         host_->GetView());
     if (!view)
       return;
 
     gfx::SizeF viewport_size_dip = gfx::ScaleSize(
         metadata.scrollable_viewport_size, metadata.page_scale_factor);
     gfx::SizeF screen_size_dip = gfx::ScaleSize(
         view->GetPhysicalBackingSize(), 1 / metadata.device_scale_factor);
 
-    param_metadata.set_device_scale_factor(metadata.device_scale_factor);
-    param_metadata.set_page_scale_factor(metadata.page_scale_factor);
-    param_metadata.set_page_scale_factor_min(metadata.min_page_scale_factor);
-    param_metadata.set_page_scale_factor_max(metadata.max_page_scale_factor);
-    param_metadata.set_offset_top(
+    param_metadata->set_device_scale_factor(metadata.device_scale_factor);
+    param_metadata->set_page_scale_factor(metadata.page_scale_factor);
+    param_metadata->set_page_scale_factor_min(metadata.min_page_scale_factor);
+    param_metadata->set_page_scale_factor_max(metadata.max_page_scale_factor);
+    param_metadata->set_offset_top(
         metadata.location_bar_content_translation.y());
-    param_metadata.set_offset_bottom(screen_size_dip.height() -
+    param_metadata->set_offset_bottom(screen_size_dip.height() -
         metadata.location_bar_content_translation.y() -
         viewport_size_dip.height());
-    param_metadata.set_device_width(screen_size_dip.width());
-    param_metadata.set_device_height(screen_size_dip.height());
-    param_metadata.set_scroll_offset_x(metadata.root_scroll_offset.x());
-    param_metadata.set_scroll_offset_y(metadata.root_scroll_offset.y());
+    param_metadata->set_device_width(screen_size_dip.width());
+    param_metadata->set_device_height(screen_size_dip.height());
+    param_metadata->set_scroll_offset_x(metadata.root_scroll_offset.x());
+    param_metadata->set_scroll_offset_y(metadata.root_scroll_offset.y());
 
-    devtools::dom::Rect viewport;
-    viewport.set_x(metadata.root_scroll_offset.x());
-    viewport.set_y(metadata.root_scroll_offset.y());
-    viewport.set_width(metadata.scrollable_viewport_size.width());
-    viewport.set_height(metadata.scrollable_viewport_size.height());
-    param_metadata.set_viewport(viewport);
+    scoped_ptr<devtools::dom::Rect> viewport;
+    viewport->set_x(metadata.root_scroll_offset.x());
+    viewport->set_y(metadata.root_scroll_offset.y());
+    viewport->set_width(metadata.scrollable_viewport_size.width());
+    viewport->set_height(metadata.scrollable_viewport_size.height());
+    param_metadata->set_viewport(viewport.Pass());
   }
 
-  ScreencastFrameParams params;
-  params.set_data(base_64_data);
-  params.set_metadata(param_metadata);
-  client_->ScreencastFrame(params);
+  scoped_ptr<ScreencastFrameParams> params;
+  params->set_data(base_64_data);
+  params->set_metadata(param_metadata.Pass());
+  client_->ScreencastFrame(params.Pass());
 }
 
 void PageHandler::ScreenshotCaptured(
     scoped_refptr<DevToolsProtocol::Command> command,
     const unsigned char* png_data,
     size_t png_size) {
   if (!png_data || !png_size) {
     client_->SendInternalErrorResponse(command,
                                        "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);
 
-  CaptureScreenshotResponse response;
-  response.set_data(base_64_data);
-  client_->SendCaptureScreenshotResponse(command, response);
+  scoped_ptr<CaptureScreenshotResponse> response;
+  response->set_data(base_64_data);
+  client_->SendCaptureScreenshotResponse(command, response.Pass());
 }
 
 void PageHandler::OnColorPicked(int r, int g, int b, int a) {
-  dom::RGBA color;
-  color.set_r(r);
-  color.set_g(g);
-  color.set_b(b);
-  color.set_a(a);
-  ColorPickedParams params;
-  params.set_color(color);
-  client_->ColorPicked(params);
+  scoped_ptr<dom::RGBA> color;
+  color->set_r(r);
+  color->set_g(g);
+  color->set_b(b);
+  color->set_a(a);
+  scoped_ptr<ColorPickedParams> params;
+  params->set_color(color.Pass());
+  client_->ColorPicked(params.Pass());
 }
 
 void PageHandler::QueryUsageAndQuotaCompleted(
     scoped_refptr<DevToolsProtocol::Command> command,
     scoped_ptr<QueryUsageAndQuotaResponse> response_data) {
-  client_->SendQueryUsageAndQuotaResponse(command, *response_data);
+  client_->SendQueryUsageAndQuotaResponse(command, response_data.Pass());
 }
 
 }  // namespace page
 }  // namespace devtools
 }  // namespace content