Clear the PrintContext in WebLocalFrameImpl::Close().

third_party/WebKit/Source/core/page/PrintContext.cpp

 /*
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2007 Apple Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 10 matching lines @@
 #include "core/page/PrintContext.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "platform/graphics/GraphicsContext.h"
 
 namespace blink {
 
+namespace {
+
 // By shrinking to a width of 75% (1.333f) we will render the correct physical
 // dimensions in paged media (i.e. cm, pt,). The shrinkage used
 // to be 80% (1.25f) to match other browsers - they have since moved on.
 // Wide pages will be scaled down more than this.
 const float kPrintingMinimumShrinkFactor = 1.333f;
 
 // This number determines how small we are willing to reduce the page content
 // in order to accommodate the widest line. If the page would have to be
 // reduced smaller to make the widest line fit, we just clip instead (this
 // behavior matches MacIE and Mozilla, at least).
 // TODO(rhogan): Decide if this quirk is still required.
 const float kPrintingMaximumShrinkFactor = 2;
 
+LayoutBoxModelObject* EnclosingBoxModelObject(LayoutObject* object) {
+  while (object && !object->IsBoxModelObject())
+    object = object->Parent();
+  if (!object)
+    return nullptr;
+  return ToLayoutBoxModelObject(object);
+}
+
+bool IsCoordinateInPage(int top, int left, const IntRect& page) {
+  return page.X() <= left && left < page.MaxX() && page.Y() <= top &&
+         top < page.MaxY();
+}
+
+}  // namespace
+
 PrintContext::PrintContext(LocalFrame* frame)
     : frame_(frame), is_printing_(false), linked_destinations_valid_(false) {}
 
 PrintContext::~PrintContext() {
-  if (is_printing_)
-    EndPrintMode();
+  DCHECK(!is_printing_);
 }
 
 void PrintContext::ComputePageRects(const FloatRect& print_rect,
                                     float header_height,
                                     float footer_height,
                                     float user_scale_factor,
                                     float& out_page_height) {
   page_rects_.clear();
   out_page_height = 0;
 
-  if (!frame_->GetDocument() || !frame_->View() ||
-      frame_->GetDocument()->GetLayoutViewItem().IsNull())
+  if (!IsFrameValid())
     return;
 
   if (user_scale_factor <= 0) {
     DLOG(ERROR) << "userScaleFactor has bad value " << user_scale_factor;
     return;
   }
 
   LayoutViewItem view = frame_->GetDocument()->GetLayoutViewItem();
   const IntRect& document_rect = view.DocumentRect();
   FloatSize page_size = frame_->ResizePageRectsKeepingRatio(
@@ skipping 16 matching lines @@
 }
 
 void PrintContext::ComputePageRectsWithPageSize(
     const FloatSize& page_size_in_pixels) {
   page_rects_.clear();
   ComputePageRectsWithPageSizeInternal(page_size_in_pixels);
 }
 
 void PrintContext::ComputePageRectsWithPageSizeInternal(
     const FloatSize& page_size_in_pixels) {
-  if (!frame_->GetDocument() || !frame_->View() ||
-      frame_->GetDocument()->GetLayoutViewItem().IsNull())
+  if (!IsFrameValid())
     return;
 
   LayoutViewItem view = frame_->GetDocument()->GetLayoutViewItem();
 
   IntRect doc_rect = view.DocumentRect();
 
   int page_width = page_size_in_pixels.Width();
   // We scaled with floating point arithmetic and need to ensure results like
   // 13329.99 are treated as 13330 so that we don't mistakenly assign an extra
   // page for the stray pixel.
@@ skipping 69 matching lines @@
   // This changes layout, so callers need to make sure that they don't paint to
   // screen while in printing mode.
   frame_->SetPrinting(
       true, min_layout_size, original_page_size,
       kPrintingMaximumShrinkFactor / kPrintingMinimumShrinkFactor);
 }
 
 void PrintContext::EndPrintMode() {
   ASSERT(is_printing_);
   is_printing_ = false;
-  frame_->SetPrinting(false, FloatSize(), FloatSize(), 0);
+  if (IsFrameValid())
+    frame_->SetPrinting(false, FloatSize(), FloatSize(), 0);
   linked_destinations_.clear();
   linked_destinations_valid_ = false;
 }
 
-static LayoutBoxModelObject* EnclosingBoxModelObject(LayoutObject* object) {
-  while (object && !object->IsBoxModelObject())
-    object = object->Parent();
-  if (!object)
-    return nullptr;
-  return ToLayoutBoxModelObject(object);
-}
-
+// static
 int PrintContext::PageNumberForElement(Element* element,
                                        const FloatSize& page_size_in_pixels) {
   element->GetDocument().UpdateStyleAndLayout();
 
   LocalFrame* frame = element->GetDocument().GetFrame();
   FloatRect page_rect(FloatPoint(0, 0), page_size_in_pixels);
   PrintContext print_context(frame);
-  print_context.BeginPrintMode(page_rect.Width(), page_rect.Height());
+  ScopedPrintMode(&print_context, page_rect.Width(), page_rect.Height());

[haraken, 2017/05/01 00:21:16]

Would it be simpler to create ScopedPrintContext (for most cases) and a
heap-allocated PrintContext (for the LocalFrameImpl case)?

[Lei Zhang, 2017/05/01 03:18:27]

Sure. See patch set 5. I tried it earlier but I did something wrong and the
blink-gc Clang plugin stopped me.

 
   LayoutBoxModelObject* box =
       EnclosingBoxModelObject(element->GetLayoutObject());
   if (!box)
     return -1;
 
   FloatSize scaled_page_size = page_size_in_pixels;
   scaled_page_size.Scale(frame->View()->ContentsSize().Width() /
                          page_rect.Width());
   print_context.ComputePageRectsWithPageSize(scaled_page_size);
 
   int top = box->PixelSnappedOffsetTop(box->OffsetParent());
   int left = box->PixelSnappedOffsetLeft(box->OffsetParent());
-  size_t page_number = 0;
-  for (; page_number < print_context.PageCount(); page_number++) {
-    const IntRect& page = print_context.PageRect(page_number);
-    if (page.X() <= left && left < page.MaxX() && page.Y() <= top &&
-        top < page.MaxY())
+  for (size_t page_number = 0; page_number < print_context.PageCount();
+       ++page_number) {
+    if (IsCoordinateInPage(top, left, print_context.PageRect(page_number)))
       return page_number;
   }
   return -1;
 }
 
 void PrintContext::CollectLinkedDestinations(Node* node) {
   for (Node* i = node->firstChild(); i; i = i->nextSibling())
     CollectLinkedDestinations(i);
 
   if (!node->IsLink() || !node->IsElementNode())
@@ skipping 32 matching lines @@
     // the root frame.
     IntPoint point = layout_object->GetFrameView()->ConvertToRootFrame(
         bounding_box.Location());
     if (!page_rect.Contains(point))
       continue;
     point.ClampNegativeToZero();
     context.SetURLDestinationLocation(entry.key, point);
   }
 }
 
+// static
 String PrintContext::PageProperty(LocalFrame* frame,
                                   const char* property_name,
                                   int page_number) {
   Document* document = frame->GetDocument();
   PrintContext print_context(frame);
   // Any non-zero size is OK here. We don't care about actual layout. We just
   // want to collect @page rules and figure out what declarations apply on a
   // given page (that may or may not exist).
-  print_context.BeginPrintMode(800, 1000);
+  ScopedPrintMode(&print_context, 800, 1000);
   RefPtr<ComputedStyle> style = document->StyleForPage(page_number);
 
   // Implement formatters for properties we care about.
   if (!strcmp(property_name, "margin-left")) {
     if (style->MarginLeft().IsAuto())
       return String("auto");
     return String::Number(style->MarginLeft().Value());
   }
   if (!strcmp(property_name, "line-height"))
     return String::Number(style->LineHeight().Value());
@@ skipping 24 matching lines @@
   frame->GetDocument()->PageSizeAndMarginsInPixels(page_number, page_size,
                                                    margin_top, margin_right,
                                                    margin_bottom, margin_left);
 
   return "(" + String::Number(floor(page_size.Width())) + ", " +
          String::Number(floor(page_size.Height())) + ") " +
          String::Number(margin_top) + ' ' + String::Number(margin_right) + ' ' +
          String::Number(margin_bottom) + ' ' + String::Number(margin_left);
 }
 
+// static
 int PrintContext::NumberOfPages(LocalFrame* frame,
                                 const FloatSize& page_size_in_pixels) {
   frame->GetDocument()->UpdateStyleAndLayout();
 
   FloatRect page_rect(FloatPoint(0, 0), page_size_in_pixels);
   PrintContext print_context(frame);
-  print_context.BeginPrintMode(page_rect.Width(), page_rect.Height());
+  ScopedPrintMode(&print_context, page_rect.Width(), page_rect.Height());
   // Account for shrink-to-fit.
   FloatSize scaled_page_size = page_size_in_pixels;
   scaled_page_size.Scale(frame->View()->ContentsSize().Width() /
                          page_rect.Width());
   print_context.ComputePageRectsWithPageSize(scaled_page_size);
   return print_context.PageCount();
 }
 
+bool PrintContext::IsFrameValid() const {
+  return frame_->View() && frame_->GetDocument() &&
+         !frame_->GetDocument()->GetLayoutViewItem().IsNull();
+}
+
 DEFINE_TRACE(PrintContext) {
   visitor->Trace(frame_);
   visitor->Trace(linked_destinations_);
 }
 
+ScopedPrintMode::ScopedPrintMode(PrintContext* context,
+                                 float width,
+                                 float height)
+    : context_(context) {
+  context_->BeginPrintMode(width, height);
+}
+
+ScopedPrintMode::~ScopedPrintMode() {
+  context_->EndPrintMode();
+}
+
 }  // namespace blink