Added Header and Footer support using Skia

chrome/renderer/print_web_view_helper.cc

 // Copyright (c) 2011 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 "chrome/renderer/print_web_view_helper.h"
 
+#include<algorithm>

[dpapad, 2011/07/19 20:34:01]

Space between words.

[Aayush Kumar, 2011/07/21 21:58:53]

Done.

 #include <string>
 
 #include "base/command_line.h"
+#include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
+#include "base/string_number_conversions.h"
+#include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/print_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "content/renderer/render_view.h"
 #include "grit/generated_resources.h"
 #include "printing/metafile_impl.h"
 #include "printing/print_job_constants.h"
 #include "printing/units.h"
+#include "skia/ext/vector_platform_device_skia.h"
+#include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/text/text_elider.h"
 
 #if defined(OS_POSIX)
 #include "content/common/view_messages.h"
 #endif
 
+using base::Time;
 using printing::ConvertPixelsToPoint;
 using printing::ConvertPixelsToPointDouble;
 using printing::ConvertUnit;
 using printing::ConvertUnitDouble;
 using WebKit::WebConsoleMessage;
 using WebKit::WebDocument;
 using WebKit::WebElement;
 using WebKit::WebFrame;
 using WebKit::WebNode;
 using WebKit::WebSize;
@@ skipping 31 matching lines @@
          oldParams.params.min_shrink == newParams.params.min_shrink &&
          oldParams.params.dpi == newParams.params.dpi &&
          oldParams.params.printable_size == newParams.params.printable_size &&
          oldParams.params.selection_only == newParams.params.selection_only &&
          oldParams.params.page_size == newParams.params.page_size &&
          oldParams.params.margin_top == newParams.params.margin_top &&
          oldParams.params.margin_left == newParams.params.margin_left &&
          oldParams.params.supports_alpha_blend ==
              newParams.params.supports_alpha_blend &&
          oldParams.pages.size() == newParams.pages.size() &&
+         oldParams.params.display_header_footer ==
+             newParams.params.display_header_footer &&
          std::equal(oldParams.pages.begin(), oldParams.pages.end(),
              newParams.pages.begin());
 }
 
+// Gets the byte length of the |text|.
+size_t GetString16ByteLength(string16 text) {
+  return text.length() * sizeof(char16);
+}
+
+// Splits the horizontal width equally into three segments with an interstice
+// between each segment.  Returns the width of this segment.
+SkScalar GetSegmentWidth(PageSizeMargins& page_size_margins) {
+  return (page_size_margins.margin_left +
+      page_size_margins.content_width +
+      page_size_margins.margin_right -
+      (printing::kSettingHeaderFooterHorizontalRegions + 1) *
+      printing::kSettingHeaderFooterInterstice) /
+      printing::kSettingHeaderFooterHorizontalRegions;
+}
+
+// Gets the (x,y) coordinate from where we want to start printing the current

[vandebo (ex-Chrome), 2011/07/19 21:31:20]

nit: (x, y)

[Aayush Kumar, 2011/07/21 21:58:53]

Done.

+// text depending on the alignment horizontal alignment (LEFT, RIGHT, CENTER)
+// and vertical alignment (TOP, BOTTOM).
+SkPoint GetHeaderFooterPosition(
+    string16 text,
+    SkPaint paint,
+    printing::HorizontalHeaderFooterPosition hor_pos,
+    printing::VerticalHeaderFooterPosition ver_pos,
+    PageSizeMargins& page_size_margins) {
+
+  SkScalar text_width_in_points = paint.measureText(
+      text.c_str(), GetString16ByteLength(text));
+
+  SkScalar x(0);

[vandebo (ex-Chrome), 2011/07/19 21:31:20]

nit: = 0; is easier to understand.

[Aayush Kumar, 2011/07/21 21:58:53]

Done.

+  switch (hor_pos) {
+    case printing::LEFT: {
+      x = page_size_margins.margin_left * (-1) +
+          printing::kSettingHeaderFooterInterstice;
+      break;
+    }
+    case printing::RIGHT: {
+      x = ((page_size_margins.content_width + page_size_margins.margin_right) -
+           (printing::kSettingHeaderFooterInterstice + text_width_in_points));
+      break;
+    }
+    case printing::CENTER: {
+      SkScalar available_width = GetSegmentWidth(page_size_margins);
+      x = (available_width - page_size_margins.margin_left +
+          (available_width - text_width_in_points) / 2);
+      break;
+    }
+    default: {
+      NOTREACHED();
+    }
+  }
+
+  SkScalar y(0);
+  switch (ver_pos) {
+    case printing::TOP: {
+      y = page_size_margins.margin_top * (-1) +
+          printing::kSettingHeaderFooterInterstice +
+          paint.getTextSize();

[vandebo (ex-Chrome), 2011/07/19 21:31:20]

As we talked about, getTextSize() doesn't tell you the height of the maximum
descender.  The more complicated version of SkPaint::measureText will give you
the bounding box of the text, from which you can calculate the total height,
etc.

[Aayush Kumar, 2011/07/21 21:58:53]

Done.

+      break;
+    }
+    case printing::BOTTOM: {
+      y = page_size_margins.margin_bottom + page_size_margins.content_height -
+          printing::kSettingHeaderFooterInterstice;
+      break;
+    }
+    default: {
+      NOTREACHED();
+    }
+  }
+
+  SkPoint point;
+  point.set(x, y);
+  return point;
+}
+
+// Given a text, the positions and the paint object, this method gets the
+// coordinates and prints the text at those co-ordinates on the canvas.
+void PrintHeaderFooterText(
+    string16 text,
+    SkPaint paint,
+    const SkRefPtr<skia::VectorCanvas>& canvas,
+    printing::HorizontalHeaderFooterPosition hor_pos,
+    printing::VerticalHeaderFooterPosition ver_pos,
+    float webkit_scale_factor,
+    PageSizeMargins& page_size_margins) {
+  SkPoint point = GetHeaderFooterPosition(text, paint, hor_pos, ver_pos,
+                                          page_size_margins);
+  point.set(point.x() / webkit_scale_factor, point.y() / webkit_scale_factor);
+  size_t byte_length = GetString16ByteLength(text);
+
+  canvas->drawText(text.c_str(), byte_length, point.x(), point.y(), paint);
+}
+
 }  // namespace
 
+// Given the device and canvas to draw on, prints the appropriate headers
+// and footers on to the canvas.
+void PrintHeaderAndFooter(SkDevice *device,

[vandebo (ex-Chrome), 2011/07/19 21:31:20]

Arguments should line up.

[vandebo (ex-Chrome), 2011/07/19 21:31:20]

Maybe this function should take an SkPDFDevice*, doing the casting at the
calling site.

[Aayush Kumar, 2011/07/21 21:58:53]

Done.

[Aayush Kumar, 2011/07/21 21:58:53]

Done.

+    const SkRefPtr<skia::VectorCanvas>& canvas,
+    int page_number, int total_pages, float webkit_scale_factor,
+    PageSizeMargins& page_size_margins,
+    const DictionaryValue* header_footer_info) {
+  // Set the drawing area to draw in the margins.
+  ((skia::VectorPlatformDeviceSkia* )device) ->

[vandebo (ex-Chrome), 2011/07/19 21:31:20]

Use C++ style casts.

[Aayush Kumar, 2011/07/21 21:58:53]

Done.

+      setDrawingArea(SkPDFDevice::kMargin_DrawingArea);
+
+  // Setting up styles for the headers and footers text.
+  SkPaint paint;
+  paint.setColor(SK_ColorBLACK);
+  paint.setTextSize(SkIntToScalar(printing::kSettingHeaderFooterFontSize) /
+                    webkit_scale_factor);
+  paint.setTypeface(SkTypeface::CreateFromName(NULL, SkTypeface::kNormal));
+  paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
+
+  // Ensuring we have enough space to print above and below the page to print

[vandebo (ex-Chrome), 2011/07/19 21:31:20]

Is it necessary to do this?  If margins are 0, the headers and footers will
simply be overwritten.

[Aayush Kumar, 2011/07/21 21:58:53]

I am afraid if the margins are more than '0', but, not large enough to be able
to print the text in completely.  In that scenario, the text will appear to be
partially overwritten - I wanted to avoid that.  This may happen either when we
give the user the choice to choose custom margins, or, on funky paper sizes.

On 2011/07/19 21:31:20, vandebo wrote:

+  // headers and footers.
+  if (GetHeaderFooterPosition(UTF8ToUTF16("dummy_string"), paint,
+      printing::LEFT, printing::TOP, page_size_margins).y() > 0) {
+    return;
+  }
+  if (page_size_margins.margin_bottom - paint.getTextSize() -
+      printing::kSettingHeaderFooterInterstice < 0) {
+    return;
+  }
+
+  SkScalar segment_width = GetSegmentWidth(page_size_margins);
+  // Printing the Date.
+  string16 date = base::TimeFormatShortDateNumeric(Time::Now());
+  date = ui::ElideText(date, paint, segment_width, false);
+  PrintHeaderFooterText(date, paint, canvas, printing::LEFT, printing::TOP,
+                        webkit_scale_factor, page_size_margins);
+
+  // Printing the title.
+  string16 title;
+  if (!header_footer_info->GetString(printing::kSettingHeaderFooterTitle,
+                                     &title)) {
+    NOTREACHED();
+  }
+
+  SkScalar date_width = paint.measureText(date.c_str(),
+                                          GetString16ByteLength(date));
+  // Calculating the available title width.  If the date string is not long
+  // enough, then, we increase the available space we have for the title.
+  // Assumes there is no header text to RIGHT of title.
+  SkScalar max_title_width = std::min(2 * segment_width,
+                                      2 * (segment_width - date_width) +
+                                          segment_width);
+  title = ui::ElideText(title, paint, max_title_width, false);
+  PrintHeaderFooterText(title, paint, canvas, printing::CENTER,
+                        printing::TOP, webkit_scale_factor,
+                        page_size_margins);
+
+  // Printing the page numbers at the bottom right corner of page.
+  string16 page_on_page_total = base::IntToString16(page_number) +
+                                UTF8ToUTF16("/") +
+                                base::IntToString16(total_pages);
+  page_on_page_total = ui::ElideText(page_on_page_total, paint, segment_width,
+                                     false);
+  PrintHeaderFooterText(page_on_page_total, paint, canvas, printing::RIGHT,
+                        printing::BOTTOM, webkit_scale_factor,
+                        page_size_margins);
+
+  // Printing the URL.
+  std::string url;
+  if (!header_footer_info->GetString(printing::kSettingHeaderFooterURL,
+                                     &url)) {
+    NOTREACHED();
+  }
+  GURL gurl(url);
+  SkScalar page_width = paint.measureText(
+      page_on_page_total.c_str(),
+      GetString16ByteLength(page_on_page_total));
+
+  // Calculating the available URL width.  We increase the available URL width
+  // if the |page_on_page_total| string isn't long enough.
+  // Assumes no footer text being printed in the CENTER.
+  SkScalar max_url_width = 3 * (page_size_margins.content_width +
+      page_size_margins.margin_left + page_size_margins.margin_right) / 4;
+  max_url_width = std::min(max_url_width,
+                           2 * (segment_width - page_width) + segment_width);
+  string16 url_elided = ui::ElideUrl(gurl, paint, max_url_width,
+                                     std::string());
+  PrintHeaderFooterText(url_elided, paint, canvas, printing::LEFT,
+                        printing::BOTTOM, webkit_scale_factor,
+                        page_size_margins);
+
+  // Restore the drawing area to draw in the content area.
+  ((skia::VectorPlatformDeviceSkia* )device)->
+      setDrawingArea(SkPDFDevice::kContent_DrawingArea);
+}
+
 PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
     const PrintMsg_Print_Params& print_params,
     WebFrame* frame,
     WebNode* node)
         : frame_(frame),
           web_view_(frame->view()),
           expected_pages_count_(0),
           use_browser_overlays_(true),
           finished_(false) {
   int dpi = GetDPI(&print_params);
@@ skipping 147 matching lines @@
       render_view()->webview()->mainFrame();
   return true;
 }
 
 void PrintWebViewHelper::OnPrintPages() {
   WebFrame* frame;
   if (GetPrintFrame(&frame))
     Print(frame, NULL);
 }
 
-void PrintWebViewHelper::OnPrintPreview(const DictionaryValue& settings) {
+void PrintWebViewHelper::OnPrintPreview(
+    const DictionaryValue& settings,
+    const DictionaryValue& header_footer_info) {
   DCHECK(is_preview_);
   print_preview_context_.OnPrintPreview();
+  header_footer_info_ = header_footer_info.DeepCopy();
 
   if (!InitPrintSettings(print_preview_context_.frame(),
                          print_preview_context_.node())) {
     NOTREACHED();
     return;
   }
 
   if (!UpdatePrintSettings(settings)) {
     DidFinishPrinting(FAIL_PREVIEW);
     return;
@@ skipping 268 matching lines @@
   return true;
 }
 #endif  // OS_MACOSX || OS_WIN
 
 void PrintWebViewHelper::didStopLoading() {
   PrintMsg_PrintPages_Params* params = print_pages_params_.get();
   DCHECK(params != NULL);
   PrintPages(*params, print_web_view_->mainFrame(), NULL);
 }
 
-void PrintWebViewHelper::GetPageSizeAndMarginsInPoints(
+PageSizeMargins PrintWebViewHelper::GetPageSizeAndMarginsInPoints(
     WebFrame* frame,
     int page_index,
-    const PrintMsg_Print_Params& default_params,
-    double* content_width_in_points,
-    double* content_height_in_points,
-    double* margin_top_in_points,
-    double* margin_right_in_points,
-    double* margin_bottom_in_points,
-    double* margin_left_in_points) {
+    const PrintMsg_Print_Params& default_params) {
   int dpi = GetDPI(&default_params);
 
   WebSize page_size_in_pixels(
       ConvertUnit(default_params.page_size.width(),
                   dpi, printing::kPixelsPerInch),
       ConvertUnit(default_params.page_size.height(),
                   dpi, printing::kPixelsPerInch));
   int margin_top_in_pixels = ConvertUnit(
       default_params.margin_top,
       dpi, printing::kPixelsPerInch);
@@ skipping 11 matching lines @@
 
   if (frame) {
     frame->pageSizeAndMarginsInPixels(page_index,
                                       page_size_in_pixels,
                                       margin_top_in_pixels,
                                       margin_right_in_pixels,
                                       margin_bottom_in_pixels,
                                       margin_left_in_pixels);
   }
 
-  *content_width_in_points = ConvertPixelsToPoint(page_size_in_pixels.width -
-                                                  margin_left_in_pixels -
-                                                  margin_right_in_pixels);
-  *content_height_in_points = ConvertPixelsToPoint(page_size_in_pixels.height -
-                                                   margin_top_in_pixels -
-                                                   margin_bottom_in_pixels);
+  PageSizeMargins page_size_margins_in_points;
+  page_size_margins_in_points.content_width = ConvertPixelsToPoint(
+      page_size_in_pixels.width - margin_left_in_pixels -
+      margin_right_in_pixels);
+  page_size_margins_in_points.content_height = ConvertPixelsToPoint(
+      page_size_in_pixels.height - margin_top_in_pixels -
+      margin_bottom_in_pixels);
 
   // Invalid page size and/or margins. We just use the default setting.
-  if (*content_width_in_points < 1.0 || *content_height_in_points < 1.0) {
-    GetPageSizeAndMarginsInPoints(NULL,
-                                  page_index,
-                                  default_params,
-                                  content_width_in_points,
-                                  content_height_in_points,
-                                  margin_top_in_points,
-                                  margin_right_in_points,
-                                  margin_bottom_in_points,
-                                  margin_left_in_points);
-    return;
+  if (page_size_margins_in_points.content_width < 1.0 ||
+      page_size_margins_in_points.content_height < 1.0) {
+    return GetPageSizeAndMarginsInPoints(NULL, page_index, default_params);
   }
 
-  if (margin_top_in_points)
-    *margin_top_in_points =
-        ConvertPixelsToPointDouble(margin_top_in_pixels);
-  if (margin_right_in_points)
-    *margin_right_in_points =
-        ConvertPixelsToPointDouble(margin_right_in_pixels);
-  if (margin_bottom_in_points)
-    *margin_bottom_in_points =
-        ConvertPixelsToPointDouble(margin_bottom_in_pixels);
-  if (margin_left_in_points)
-    *margin_left_in_points =
-        ConvertPixelsToPointDouble(margin_left_in_pixels);
+  page_size_margins_in_points.margin_top =
+      ConvertPixelsToPointDouble(margin_top_in_pixels);
+  page_size_margins_in_points.margin_right =
+      ConvertPixelsToPointDouble(margin_right_in_pixels);
+  page_size_margins_in_points.margin_bottom =
+      ConvertPixelsToPointDouble(margin_bottom_in_pixels);
+  page_size_margins_in_points.margin_left =
+      ConvertPixelsToPointDouble(margin_left_in_pixels);
+  return page_size_margins_in_points;
 }
 
 void PrintWebViewHelper::UpdatePrintableSizeInPrintParameters(
     WebFrame* frame,
     WebNode* node,
     PrintMsg_Print_Params* params) {
-  double content_width_in_points;
-  double content_height_in_points;
-  double margin_top_in_points;
-  double margin_right_in_points;
-  double margin_bottom_in_points;
-  double margin_left_in_points;
   PrepareFrameAndViewForPrint prepare(*params, frame, node);
-  PrintWebViewHelper::GetPageSizeAndMarginsInPoints(frame, 0, *params,
-      &content_width_in_points, &content_height_in_points,
-      &margin_top_in_points, &margin_right_in_points,
-      &margin_bottom_in_points, &margin_left_in_points);
+  PageSizeMargins page_size_margins_in_points =
+      PrintWebViewHelper::GetPageSizeAndMarginsInPoints(frame, 0, *params);
   int dpi = GetDPI(params);
   params->printable_size = gfx::Size(
-      static_cast<int>(ConvertUnitDouble(content_width_in_points,
+      static_cast<int>(ConvertUnitDouble(
+          page_size_margins_in_points.content_width,
           printing::kPointsPerInch, dpi)),
-      static_cast<int>(ConvertUnitDouble(content_height_in_points,
+      static_cast<int>(ConvertUnitDouble(
+          page_size_margins_in_points.content_height,
           printing::kPointsPerInch, dpi)));
 
-  double page_width_in_points = content_width_in_points +
-      margin_left_in_points + margin_right_in_points;
-  double page_height_in_points = content_height_in_points +
-      margin_top_in_points + margin_bottom_in_points;
+  double page_width_in_points = page_size_margins_in_points.content_width +
+      page_size_margins_in_points.margin_left +
+      page_size_margins_in_points.margin_right;
+  double page_height_in_points = page_size_margins_in_points.content_height +
+      page_size_margins_in_points.margin_top +
+      page_size_margins_in_points.margin_bottom;
 
   params->page_size = gfx::Size(
       static_cast<int>(ConvertUnitDouble(
           page_width_in_points, printing::kPointsPerInch, dpi)),
       static_cast<int>(ConvertUnitDouble(
           page_height_in_points, printing::kPointsPerInch, dpi)));
 
   params->margin_top = static_cast<int>(ConvertUnitDouble(
-      margin_top_in_points, printing::kPointsPerInch, dpi));
+      page_size_margins_in_points.margin_top, printing::kPointsPerInch, dpi));
   params->margin_left = static_cast<int>(ConvertUnitDouble(
-      margin_left_in_points, printing::kPointsPerInch, dpi));
+      page_size_margins_in_points.margin_left, printing::kPointsPerInch, dpi));
 }
 
 bool PrintWebViewHelper::InitPrintSettings(WebKit::WebFrame* frame,
                                            WebKit::WebNode* node) {
   DCHECK(frame);
   PrintMsg_PrintPages_Params settings;
 
   // TODO(abodenha@chromium.org) It doesn't make sense to do this if our
   // "default" is a cloud based printer.  Split InitPrintSettings up
   // so that we can avoid the overhead of unneeded calls into the native
@@ skipping 35 matching lines @@
   settings.params.margin_top = 150;
   settings.params.margin_left = 150;
   settings.params.dpi = 300.0;
   settings.params.min_shrink = 1.25;
   settings.params.max_shrink = 2.0;
   settings.params.desired_dpi = 72;
   settings.params.selection_only = false;
   settings.params.supports_alpha_blend = false;
   // TODO(abodenha@chromium.org) Parse page ranges from the job_settings.
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
+  print_pages_params_->params.display_header_footer = false;
   return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettingsLocal(
     const DictionaryValue& job_settings) {
   PrintMsg_PrintPages_Params settings;
 
   Send(new PrintHostMsg_UpdatePrintSettings(routing_id(),
       print_pages_params_->params.document_cookie, job_settings, &settings));
 
   if (settings.params.dpi < kMinDpi || !settings.params.document_cookie)
     return false;
 
   if (!job_settings.GetInteger(printing::kPreviewRequestID,
                                &settings.params.preview_request_id)) {
     NOTREACHED();
     return false;
   }
 
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
+  bool header_footer;
+  if (!job_settings.GetBoolean(printing::kSettingHeaderFooter, &header_footer))
+    NOTREACHED();
+  print_pages_params_->params.display_header_footer = header_footer;
+
   Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
                                              settings.params.document_cookie));
   return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
     const DictionaryValue& job_settings) {
   if (job_settings.HasKey(printing::kSettingCloudPrintId)) {
     return UpdatePrintSettingsCloud(job_settings);
   } else {
@@ skipping 301 matching lines @@
 const gfx::Size&
 PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   rendered_pages_.clear();
 }