Move printing-related methods from WebFrame to WebLocalFrame.

content/shell/test_runner/pixel_dump.cc

 // Copyright 2016 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/shell/test_runner/pixel_dump.h"
 
 #include <memory>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/paint/paint_flags.h"
 #include "cc/paint/skia_paint_canvas.h"
 #include "content/shell/test_runner/layout_test_runtime_flags.h"
@@ skipping 23 matching lines @@
         layout_test_runtime_flags(layout_test_runtime_flags),
         callback(callback) {}
 
   blink::WebView* web_view;
   const LayoutTestRuntimeFlags& layout_test_runtime_flags;
   base::Callback<void(const SkBitmap&)> callback;
 };
 
 class CaptureCallback : public blink::WebCompositeAndReadbackAsyncCallback {
  public:
-  CaptureCallback(const base::Callback<void(const SkBitmap&)>& callback);
+  explicit CaptureCallback(
+      const base::Callback<void(const SkBitmap&)>& callback);
   virtual ~CaptureCallback();
 
   void set_wait_for_popup(bool wait) { wait_for_popup_ = wait; }
   void set_popup_position(const gfx::Point& position) {
     popup_position_ = position;
   }
 
   // WebCompositeAndReadbackAsyncCallback implementation.
   void DidCompositeAndReadback(const SkBitmap& bitmap) override;
 
  private:
   base::Callback<void(const SkBitmap&)> callback_;
   SkBitmap main_bitmap_;
   bool wait_for_popup_;
   gfx::Point popup_position_;
 };
 
 void DrawSelectionRect(const PixelsDumpRequest& dump_request,
                        cc::PaintCanvas* canvas) {
   // See if we need to draw the selection bounds rect. Selection bounds
   // rect is the rect enclosing the (possibly transformed) selection.
   // The rect should be drawn after everything is laid out and painted.
   if (!dump_request.layout_test_runtime_flags.dump_selection_rect())
     return;
   // If there is a selection rect - draw a red 1px border enclosing rect
-  blink::WebRect wr = dump_request.web_view->MainFrame()->SelectionBoundsRect();
+  CHECK(dump_request.web_view->MainFrame()->IsWebLocalFrame())
+      << "This function cannot be called if the main frame is not a "
+         "local frame.";
+  blink::WebRect wr = dump_request.web_view->MainFrame()
+                          ->ToWebLocalFrame()
+                          ->GetSelectionBoundsRectForTesting();
   if (wr.IsEmpty())
     return;
   // Render a red rectangle bounding selection rect
   cc::PaintFlags flags;
   flags.setColor(0xFFFF0000);  // Fully opaque red
   flags.setStyle(cc::PaintFlags::kStroke_Style);
   flags.setAntiAlias(true);
   flags.setStrokeWidth(1.0f);
   SkIRect rect;  // Bounding rect
   rect.set(wr.x, wr.y, wr.x + wr.width, wr.y + wr.height);
   canvas->drawIRect(rect, flags);
 }
 
 void CapturePixelsForPrinting(std::unique_ptr<PixelsDumpRequest> dump_request) {
   dump_request->web_view->UpdateAllLifecyclePhases();
 
   blink::WebSize page_size_in_pixels = dump_request->web_view->Size();
-  blink::WebFrame* web_frame = dump_request->web_view->MainFrame();
+
+  CHECK(dump_request->web_view->MainFrame()->IsWebLocalFrame())
+      << "This function cannot be called if the main frame is not a "
+         "local frame.";
+  blink::WebLocalFrame* web_frame =
+      dump_request->web_view->MainFrame()->ToWebLocalFrame();
 
   int page_count = web_frame->PrintBegin(page_size_in_pixels);
   int totalHeight = page_count * (page_size_in_pixels.height + 1) - 1;
 
   bool is_opaque = false;
 
   SkBitmap bitmap;
   if (!bitmap.tryAllocN32Pixels(page_size_in_pixels.width, totalHeight,
                                 is_opaque)) {
     LOG(ERROR) << "Failed to create bitmap width=" << page_size_in_pixels.width
                << " height=" << totalHeight;
     dump_request->callback.Run(SkBitmap());
     return;
   }
 
   cc::SkiaPaintCanvas canvas(bitmap);
-  web_frame->PrintPagesWithBoundaries(&canvas, page_size_in_pixels);
+  web_frame->PrintPagesForTesting(&canvas, page_size_in_pixels);
   web_frame->PrintEnd();
 
   DrawSelectionRect(*dump_request, &canvas);
   dump_request->callback.Run(bitmap);
 }
 
 CaptureCallback::CaptureCallback(
     const base::Callback<void(const SkBitmap&)>& callback)
     : callback_(callback), wait_for_popup_(false) {}
 
@@ skipping 81 matching lines @@
     return;
   }
 
   blink::WebImage image = static_cast<blink::WebMockClipboard*>(
                               blink::Platform::Current()->Clipboard())
                               ->ReadRawImage(blink::WebClipboard::Buffer());
   callback.Run(image.GetSkBitmap());
 }
 
 }  // namespace test_runner