[DevTools] Migrate dom, emulation, inspector, network, page and schema handlers to new generator.

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 22 matching lines @@
 #include "content/public/common/referrer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/snapshot/snapshot.h"
 #include "url/gurl.h"
 
 namespace content {
-namespace devtools {
-namespace page {
+namespace protocol {
 
 namespace {
 
 static const char kPng[] = "png";
 static const char kJpeg[] = "jpeg";
 static int kDefaultScreenshotQuality = 80;
 static int kFrameRetryDelayMs = 100;
 static int kCaptureRetryLimit = 2;
 static int kMaxScreencastFramesInFlight = 2;
 
@@ skipping 28 matching lines @@
   std::string base_64_data;
   base::Base64Encode(
       base::StringPiece(reinterpret_cast<char*>(&data[0]), data.size()),
       &base_64_data);
 
   return base_64_data;
 }
 
 }  // namespace
 
-typedef DevToolsProtocolClient::Response Response;
-
 PageHandler::PageHandler()
     : enabled_(false),
       screencast_enabled_(false),
       screencast_quality_(kDefaultScreenshotQuality),
       screencast_max_width_(-1),
       screencast_max_height_(-1),
       capture_every_nth_frame_(1),
       capture_retry_count_(0),
       has_compositor_frame_metadata_(false),
       session_id_(0),
@@ skipping 27 matching lines @@
   color_picker_->SetRenderWidgetHost(widget_host);
 
   if (widget_host) {
     registrar_.Add(
         this,
         content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
         content::Source<RenderWidgetHost>(widget_host));
   }
 }
 
-void PageHandler::SetClient(std::unique_ptr<Client> client) {
-  client_.swap(client);
-}
-
-void PageHandler::Detached() {
-  Disable();
+void PageHandler::Wire(UberDispatcher* dispatcher) {
+  frontend_.reset(new Page::Frontend(dispatcher->channel()));
+  Page::Dispatcher::wire(dispatcher, this);
 }
 
 void PageHandler::OnSwapCompositorFrame(
     cc::CompositorFrameMetadata frame_metadata) {
   last_compositor_frame_metadata_ = std::move(frame_metadata);
   has_compositor_frame_metadata_ = true;
 
   if (screencast_enabled_)
     InnerSwapCompositorFrame();
   color_picker_->OnSwapCompositorFrame();
@@ skipping 22 matching lines @@
   if (!screencast_enabled_)
     return;
   DCHECK(type == content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED);
   bool visible = *Details<bool>(details).ptr();
   NotifyScreencastVisibility(visible);
 }
 
 void PageHandler::DidAttachInterstitialPage() {
   if (!enabled_)
     return;
-  client_->InterstitialShown(InterstitialShownParams::Create());
+  frontend_->InterstitialShown();
 }
 
 void PageHandler::DidDetachInterstitialPage() {
   if (!enabled_)
     return;
-  client_->InterstitialHidden(InterstitialHiddenParams::Create());
+  frontend_->InterstitialHidden();
 }
 
 Response PageHandler::Enable() {
   enabled_ = true;
   if (GetWebContents() && GetWebContents()->ShowingInterstitialPage())
-    client_->InterstitialShown(InterstitialShownParams::Create());
+    frontend_->InterstitialShown();
   return Response::FallThrough();
 }
 
 Response PageHandler::Disable() {
   enabled_ = false;
   screencast_enabled_ = false;
   SetControlNavigations(false);
   color_picker_->SetEnabled(false);
   return Response::FallThrough();
 }
 
-Response PageHandler::Reload(const bool* bypassCache,
-                             const std::string* script_to_evaluate_on_load,
-                             const std::string* script_preprocessor) {
+Response PageHandler::Reload(Maybe<bool> bypassCache,
+                             Maybe<std::string> script_to_evaluate_on_load) {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
 
   if (web_contents->IsCrashed() ||
       (web_contents->GetController().GetVisibleEntry() &&
        web_contents->GetController().GetVisibleEntry()->IsViewSourceMode())) {
-    if (bypassCache && *bypassCache)
+    if (bypassCache.fromMaybe(false))
       web_contents->GetController().ReloadBypassingCache(false);
     else
       web_contents->GetController().Reload(false);
     return Response::OK();
   } else {
     // Handle reload in renderer except for crashed and view source mode.
     return Response::FallThrough();
   }
 }
 
 Response PageHandler::Navigate(const std::string& url,
-                               FrameId* frame_id) {
+                               Page::FrameId* frame_id) {
   GURL gurl(url);
   if (!gurl.is_valid())
-    return Response::InternalError("Cannot navigate to invalid URL");
+    return Response::Error("Cannot navigate to invalid URL");
 
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
 
   web_contents->GetController()
       .LoadURL(gurl, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   return Response::FallThrough();
 }
 
-Response PageHandler::GetNavigationHistory(int* current_index,
-                                           NavigationEntries* entries) {
+Response PageHandler::GetNavigationHistory(
+    int* current_index,
+    std::unique_ptr<NavigationEntries>* entries) {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
 
   NavigationController& controller = web_contents->GetController();
   *current_index = controller.GetCurrentEntryIndex();
+  *entries = NavigationEntries::create();
   for (int i = 0; i != controller.GetEntryCount(); ++i) {
-    entries->push_back(NavigationEntry::Create()
-        ->set_id(controller.GetEntryAtIndex(i)->GetUniqueID())
-        ->set_url(controller.GetEntryAtIndex(i)->GetURL().spec())
-        ->set_title(
-            base::UTF16ToUTF8(controller.GetEntryAtIndex(i)->GetTitle())));
+    (*entries)->addItem(Page::NavigationEntry::Create()
+        .SetId(controller.GetEntryAtIndex(i)->GetUniqueID())
+        .SetUrl(controller.GetEntryAtIndex(i)->GetURL().spec())
+        .SetTitle(base::UTF16ToUTF8(controller.GetEntryAtIndex(i)->GetTitle()))
+        .Build());
   }
   return Response::OK();
 }
 
 Response PageHandler::NavigateToHistoryEntry(int entry_id) {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
 
   NavigationController& controller = web_contents->GetController();
   for (int i = 0; i != controller.GetEntryCount(); ++i) {
     if (controller.GetEntryAtIndex(i)->GetUniqueID() == entry_id) {
       controller.GoToIndex(i);
       return Response::OK();
     }
   }
 
   return Response::InvalidParams("No entry with passed id");
 }
 
-Response PageHandler::CaptureScreenshot(DevToolsCommandId command_id) {
-  if (!host_ || !host_->GetRenderWidgetHost())
-    return Response::InternalError("Could not connect to view");
+void PageHandler::CaptureScreenshot(
+    std::unique_ptr<CaptureScreenshotCallback> callback) {
+  if (!host_ || !host_->GetRenderWidgetHost()) {
+    callback->sendFailure(Response::InternalError());
+    return;
+  }
 
   host_->GetRenderWidgetHost()->GetSnapshotFromBrowser(
       base::Bind(&PageHandler::ScreenshotCaptured,
-          weak_factory_.GetWeakPtr(), command_id));
-  return Response::OK();
+          weak_factory_.GetWeakPtr(), base::Passed(std::move(callback))));
 }
 
-Response PageHandler::StartScreencast(const std::string* format,
-                                      const int* quality,
-                                      const int* max_width,
-                                      const int* max_height,
-                                      const int* every_nth_frame) {
+Response PageHandler::StartScreencast(Maybe<std::string> format,
+                                      Maybe<int> quality,
+                                      Maybe<int> max_width,
+                                      Maybe<int> max_height,
+                                      Maybe<int> every_nth_frame) {
   RenderWidgetHostImpl* widget_host =
       host_ ? host_->GetRenderWidgetHost() : nullptr;
   if (!widget_host)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
 
   screencast_enabled_ = true;
-  screencast_format_ = format ? *format : kPng;
-  screencast_quality_ = quality ? *quality : kDefaultScreenshotQuality;
+  screencast_format_ = format.fromMaybe(kPng);
+  screencast_quality_ = quality.fromMaybe(kDefaultScreenshotQuality);
   if (screencast_quality_ < 0 || screencast_quality_ > 100)
     screencast_quality_ = kDefaultScreenshotQuality;
-  screencast_max_width_ = max_width ? *max_width : -1;
-  screencast_max_height_ = max_height ? *max_height : -1;
+  screencast_max_width_ = max_width.fromMaybe(-1);
+  screencast_max_height_ = max_height.fromMaybe(-1);
   ++session_id_;
   frame_counter_ = 0;
   frames_in_flight_ = 0;
-  capture_every_nth_frame_ =
-      every_nth_frame && *every_nth_frame ? *every_nth_frame : 1;
+  capture_every_nth_frame_ = every_nth_frame.fromMaybe(1);
 
   bool visible = !widget_host->is_hidden();
   NotifyScreencastVisibility(visible);
   if (visible) {
     if (has_compositor_frame_metadata_) {
       InnerSwapCompositorFrame();
     } else {
       widget_host->Send(new ViewMsg_ForceRedraw(widget_host->GetRoutingID(),
                                                 ui::LatencyInfo()));
     }
   }
   return Response::FallThrough();
 }
 
 Response PageHandler::StopScreencast() {
   screencast_enabled_ = false;
   return Response::FallThrough();
 }
 
 Response PageHandler::ScreencastFrameAck(int session_id) {
   if (session_id == session_id_)
     --frames_in_flight_;
   return Response::OK();
 }
 
 Response PageHandler::HandleJavaScriptDialog(bool accept,
-                                             const std::string* prompt_text) {
+                                             Maybe<std::string> prompt_text) {
   base::string16 prompt_override;
-  if (prompt_text)
-    prompt_override = base::UTF8ToUTF16(*prompt_text);
+  if (prompt_text.isJust())
+    prompt_override = base::UTF8ToUTF16(prompt_text.fromJust());
 
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
 
   JavaScriptDialogManager* manager =
       web_contents->GetDelegate()->GetJavaScriptDialogManager(web_contents);
   if (manager && manager->HandleJavaScriptDialog(
-          web_contents, accept, prompt_text ? &prompt_override : nullptr)) {
+          web_contents, accept,
+          prompt_text.isJust() ? &prompt_override : nullptr)) {
     return Response::OK();
   }
 
-  return Response::InternalError("Could not handle JavaScript dialog");
-}
-
-Response PageHandler::QueryUsageAndQuota(DevToolsCommandId command_id,
-                                         const std::string& security_origin) {
-  return Response::OK();
+  return Response::Error("Could not handle JavaScript dialog");
 }
 
 Response PageHandler::SetColorPickerEnabled(bool enabled) {
   if (!host_)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
 
   color_picker_->SetEnabled(enabled);
   return Response::OK();
 }
 
 Response PageHandler::RequestAppBanner() {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
   web_contents->GetDelegate()->RequestAppBannerFromDevTools(web_contents);
   return Response::OK();
 }
 
 Response PageHandler::SetControlNavigations(bool enabled) {
   navigation_throttle_enabled_ = enabled;
   // We don't own the page PageNavigationThrottles so we can't delete them, but
   // we can turn them into NOPs.
   for (auto& pair : navigation_throttles_) {
     pair.second->AlwaysProceed();
   }
   navigation_throttles_.clear();
   return Response::OK();
 }
 
 Response PageHandler::ProcessNavigation(const std::string& response,
                                         int navigation_id) {
   auto it = navigation_throttles_.find(navigation_id);
   if (it == navigation_throttles_.end())
     return Response::InvalidParams("Unknown navigation id");
 
-  if (response == kNavigationResponseProceed) {
+  if (response == Page::NavigationResponseEnum::Proceed) {
     it->second->Resume();
     return Response::OK();
-  } else if (response == kNavigationResponseCancel) {
+  } else if (response == Page::NavigationResponseEnum::Cancel) {
     it->second->CancelDeferredNavigation(content::NavigationThrottle::CANCEL);
     return Response::OK();
-  } else if (response == kNavigationResponseCancelAndIgnore) {
+  } else if (response == Page::NavigationResponseEnum::CancelAndIgnore) {
     it->second->CancelDeferredNavigation(
         content::NavigationThrottle::CANCEL_AND_IGNORE);
     return Response::OK();
   }
 
   return Response::InvalidParams("Unrecognized response");
 }
 
-Response PageHandler::AddScriptToEvaluateOnLoad(const std::string& source,
-                                                std::string* identifier) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::RemoveScriptToEvaluateOnLoad(
-    const std::string& identifier) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::SetAutoAttachToCreatedPages(bool auto_attach) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::GetResourceTree(scoped_refptr<FrameResourceTree>* tree) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::GetResourceContent(DevToolsCommandId command_id,
-                                         const std::string& frame_id,
-                                         const std::string& url) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::SearchInResource(DevToolsCommandId command_id,
-                                       const std::string& frame_id,
-                                       const std::string& url,
-                                       const std::string& query,
-                                       bool* case_sensitive,
-                                       bool* is_regex) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::SetDocumentContent(const std::string& frame_id,
-                                         const std::string& html) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::ConfigureOverlay(const bool* is_suspended,
-                                       const std::string* message) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::GetAppManifest(
-    std::string* url,
-    std::vector<scoped_refptr<AppManifestError>>* errors,
-    std::string* data) {
-  return Response::FallThrough();
-}
-
-Response PageHandler::GetLayoutMetrics(
-    scoped_refptr<LayoutViewport>* layout_viewport,
-    scoped_refptr<VisualViewport>* visual_viewport) {
-  return Response::FallThrough();
-}
-
 std::unique_ptr<PageNavigationThrottle>
 PageHandler::CreateThrottleForNavigation(NavigationHandle* navigation_handle) {
   if (!navigation_throttle_enabled_)
     return nullptr;
 
   std::unique_ptr<PageNavigationThrottle> throttle(new PageNavigationThrottle(
       weak_factory_.GetWeakPtr(), next_navigation_id_, navigation_handle));
   navigation_throttles_[next_navigation_id_++] = throttle.get();
   return throttle;
 }
 
 void PageHandler::OnPageNavigationThrottleDisposed(int navigation_id) {
   DCHECK(navigation_throttles_.find(navigation_id) !=
          navigation_throttles_.end());
   navigation_throttles_.erase(navigation_id);
 }
 
 void PageHandler::NavigationRequested(const PageNavigationThrottle* throttle) {
   NavigationHandle* navigation_handle = throttle->navigation_handle();
-  client_->NavigationRequested(
-      NavigationRequestedParams::Create()
-          ->set_is_in_main_frame(navigation_handle->IsInMainFrame())
-          ->set_is_redirect(navigation_handle->WasServerRedirect())
-          ->set_navigation_id(throttle->navigation_id())
-          ->set_url(navigation_handle->GetURL().spec()));
+  frontend_->NavigationRequested(
+      navigation_handle->IsInMainFrame(),
+      navigation_handle->WasServerRedirect(),
+      throttle->navigation_id(),
+      navigation_handle->GetURL().spec());
 }
 
 WebContentsImpl* PageHandler::GetWebContents() {
   return host_ ?
       static_cast<WebContentsImpl*>(WebContents::FromRenderFrameHost(host_)) :
       nullptr;
 }
 
 void PageHandler::NotifyScreencastVisibility(bool visible) {
   if (visible)
     capture_retry_count_ = kCaptureRetryLimit;
-  client_->ScreencastVisibilityChanged(
-      ScreencastVisibilityChangedParams::Create()->set_visible(visible));
+  frontend_->ScreencastVisibilityChanged(visible);
 }
 
 void PageHandler::InnerSwapCompositorFrame() {
   if (!host_ || !host_->GetView())
     return;
 
   if (frames_in_flight_ > kMaxScreencastFramesInFlight)
     return;
 
   if (++frame_counter_ % capture_every_nth_frame_)
@@ skipping 77 matching lines @@
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
       host_->GetView());
   if (!view) {
     --frames_in_flight_;
     return;
   }
 
   gfx::SizeF screen_size_dip =
       gfx::ScaleSize(gfx::SizeF(view->GetPhysicalBackingSize()),
                      1 / metadata.device_scale_factor);
-  scoped_refptr<ScreencastFrameMetadata> param_metadata =
-      ScreencastFrameMetadata::Create()
-          ->set_page_scale_factor(metadata.page_scale_factor)
-          ->set_offset_top(metadata.top_controls_height *
-                           metadata.top_controls_shown_ratio)
-          ->set_device_width(screen_size_dip.width())
-          ->set_device_height(screen_size_dip.height())
-          ->set_scroll_offset_x(metadata.root_scroll_offset.x())
-          ->set_scroll_offset_y(metadata.root_scroll_offset.y())
-          ->set_timestamp(timestamp.ToDoubleT());
-  client_->ScreencastFrame(ScreencastFrameParams::Create()
-      ->set_data(data)
-      ->set_metadata(param_metadata)
-      ->set_session_id(session_id_));
+  std::unique_ptr<Page::ScreencastFrameMetadata> param_metadata =
+      Page::ScreencastFrameMetadata::Create()
+          .SetPageScaleFactor(metadata.page_scale_factor)
+          .SetOffsetTop(metadata.top_controls_height *
+                        metadata.top_controls_shown_ratio)
+          .SetDeviceWidth(screen_size_dip.width())
+          .SetDeviceHeight(screen_size_dip.height())
+          .SetScrollOffsetX(metadata.root_scroll_offset.x())
+          .SetScrollOffsetY(metadata.root_scroll_offset.y())
+          .SetTimestamp(timestamp.ToDoubleT())
+          .Build();
+  frontend_->ScreencastFrame(data, std::move(param_metadata), session_id_);
 }
 
-void PageHandler::ScreenshotCaptured(DevToolsCommandId command_id,
-                                     const unsigned char* png_data,
-                                     size_t png_size) {
+void PageHandler::ScreenshotCaptured(
+    std::unique_ptr<CaptureScreenshotCallback> callback,
+    const unsigned char* png_data,
+    size_t png_size) {
   if (!png_data || !png_size) {
-    client_->SendError(command_id,
-                       Response::InternalError("Unable to capture screenshot"));
+    callback->sendFailure(Response::Error("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);
-
-  client_->SendCaptureScreenshotResponse(command_id,
-      CaptureScreenshotResponse::Create()->set_data(base_64_data));
+  callback->sendSuccess(base_64_data);
 }
 
 void PageHandler::OnColorPicked(int r, int g, int b, int a) {
-  scoped_refptr<dom::RGBA> color =
-      dom::RGBA::Create()->set_r(r)->set_g(g)->set_b(b)->set_a(a);
-  client_->ColorPicked(ColorPickedParams::Create()->set_color(color));
+  frontend_->ColorPicked(
+      DOM::RGBA::Create().SetR(r).SetG(g).SetB(b).SetA(a).Build());
 }
 
 Response PageHandler::StopLoading() {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::InternalError("Could not connect to view");
+    return Response::InternalError();
   web_contents->Stop();
   return Response::OK();
 }
 
-}  // namespace page
-}  // namespace devtools
+}  // namespace protocol
 }  // namespace content