BASELINE: Update Chromium to 52.0.2743.76 and Ninja to 1.7.1

Change-Id: I382f51b959689505a60f8b707255ecb344f7d8b4
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

12 files changed, 186 insertions, 184 deletions

diff --git a/chromium/printing/BUILD.gn b/chromium/printing/BUILD.gn
index 7a240e2913c..4046dc4f4b9 100644
--- a/chromium/printing/BUILD.gn
+++ b/chromium/printing/BUILD.gn
@@ -100,6 +100,12 @@ component("printing") {
         "printing_context_mac.mm",
       ]
     }
+    libs = [
+      "AppKit.framework",
+      "ApplicationServices.framework",
+      "CoreFoundation.framework",
+      "CoreGraphics.framework",
+    ]
   }
 
   if (is_win) {
diff --git a/chromium/printing/backend/cups_helper.cc b/chromium/printing/backend/cups_helper.cc
index dbc6c5fdca3..4eaad46be61 100644
--- a/chromium/printing/backend/cups_helper.cc
+++ b/chromium/printing/backend/cups_helper.cc
@@ -7,6 +7,9 @@
 #include <cups/ppd.h>
 #include <stddef.h>
 
+#include <string>
+#include <vector>
+
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
@@ -40,8 +43,9 @@ const char kPageSize[] = "PageSize";
 const double kMicronsPerPoint = 10.0f * kHundrethsMMPerInch / kPointsPerInch;
 
 void ParseLpOptions(const base::FilePath& filepath,
-                    const std::string& printer_name,
-                    int* num_options, cups_option_t** options) {
+                    base::StringPiece printer_name,
+                    int* num_options,
+                    cups_option_t** options) {
   std::string content;
   if (!base::ReadFileToString(filepath, &content))
     return;
@@ -86,14 +90,15 @@ void ParseLpOptions(const base::FilePath& filepath,
     line = base::TrimWhitespaceASCII(line, base::TRIM_ALL);
     if (line.empty())
       continue;
+
     // Parse the selected printer custom options. Need to pass a
     // null-terminated string.
     *num_options = cupsParseOptions(line.as_string().c_str(), 0, options);
   }
 }
 
-void MarkLpOptions(const std::string& printer_name, ppd_file_t** ppd) {
-  cups_option_t* options = NULL;
+void MarkLpOptions(base::StringPiece printer_name, ppd_file_t** ppd) {
+  cups_option_t* options = nullptr;
   int num_options = 0;
 
   const char kSystemLpOptionPath[] = "/etc/cups/lpoptions";
@@ -105,11 +110,10 @@ void MarkLpOptions(const std::string& printer_name, ppd_file_t** ppd) {
   PathService::Get(base::DIR_HOME, &homedir);
   file_locations.push_back(base::FilePath(homedir.Append(kUserLpOptionPath)));
 
-  for (std::vector<base::FilePath>::const_iterator it = file_locations.begin();
-       it != file_locations.end(); ++it) {
+  for (const base::FilePath& location : file_locations) {
     num_options = 0;
-    options = NULL;
-    ParseLpOptions(*it, printer_name, &num_options, &options);
+    options = nullptr;
+    ParseLpOptions(location, printer_name, &num_options, &options);
     if (num_options > 0 && options) {
       cupsMarkOptions(*ppd, num_options, options);
       cupsFreeOptions(num_options, options);
@@ -125,29 +129,29 @@ bool GetBasicColorModelSettings(ppd_file_t* ppd,
   if (!color_model)
     return false;
 
-  if (ppdFindChoice(color_model, printing::kBlack))
-    *color_model_for_black = printing::BLACK;
-  else if (ppdFindChoice(color_model, printing::kGray))
-    *color_model_for_black = printing::GRAY;
-  else if (ppdFindChoice(color_model, printing::kGrayscale))
-    *color_model_for_black = printing::GRAYSCALE;
-
-  if (ppdFindChoice(color_model, printing::kColor))
-    *color_model_for_color = printing::COLOR;
-  else if (ppdFindChoice(color_model, printing::kCMYK))
-    *color_model_for_color = printing::CMYK;
-  else if (ppdFindChoice(color_model, printing::kRGB))
-    *color_model_for_color = printing::RGB;
-  else if (ppdFindChoice(color_model, printing::kRGBA))
-    *color_model_for_color = printing::RGBA;
-  else if (ppdFindChoice(color_model, printing::kRGB16))
-    *color_model_for_color = printing::RGB16;
-  else if (ppdFindChoice(color_model, printing::kCMY))
-    *color_model_for_color = printing::CMY;
-  else if (ppdFindChoice(color_model, printing::kKCMY))
-    *color_model_for_color = printing::KCMY;
-  else if (ppdFindChoice(color_model, printing::kCMY_K))
-    *color_model_for_color = printing::CMY_K;
+  if (ppdFindChoice(color_model, kBlack))
+    *color_model_for_black = BLACK;
+  else if (ppdFindChoice(color_model, kGray))
+    *color_model_for_black = GRAY;
+  else if (ppdFindChoice(color_model, kGrayscale))
+    *color_model_for_black = GRAYSCALE;
+
+  if (ppdFindChoice(color_model, kColor))
+    *color_model_for_color = COLOR;
+  else if (ppdFindChoice(color_model, kCMYK))
+    *color_model_for_color = CMYK;
+  else if (ppdFindChoice(color_model, kRGB))
+    *color_model_for_color = RGB;
+  else if (ppdFindChoice(color_model, kRGBA))
+    *color_model_for_color = RGBA;
+  else if (ppdFindChoice(color_model, kRGB16))
+    *color_model_for_color = RGB16;
+  else if (ppdFindChoice(color_model, kCMY))
+    *color_model_for_color = CMY;
+  else if (ppdFindChoice(color_model, kKCMY))
+    *color_model_for_color = KCMY;
+  else if (ppdFindChoice(color_model, kCMY_K))
+    *color_model_for_color = CMY_K;
 
   ppd_choice_t* marked_choice = ppdFindMarkedChoice(ppd, kColorModel);
   if (!marked_choice)
@@ -155,12 +159,9 @@ bool GetBasicColorModelSettings(ppd_file_t* ppd,
 
   if (marked_choice) {
     *color_is_default =
-        !base::EqualsCaseInsensitiveASCII(marked_choice->choice,
-                                          printing::kBlack) &&
-        !base::EqualsCaseInsensitiveASCII(marked_choice->choice,
-                                          printing::kGray) &&
-        !base::EqualsCaseInsensitiveASCII(marked_choice->choice,
-                                          printing::kGrayscale);
+        !base::EqualsCaseInsensitiveASCII(marked_choice->choice, kBlack) &&
+        !base::EqualsCaseInsensitiveASCII(marked_choice->choice, kGray) &&
+        !base::EqualsCaseInsensitiveASCII(marked_choice->choice, kGrayscale);
   }
   return true;
 }
@@ -173,15 +174,15 @@ bool GetPrintOutModeColorSettings(ppd_file_t* ppd,
   if (!printout_mode)
     return false;
 
-  *color_model_for_color = printing::PRINTOUTMODE_NORMAL;
-  *color_model_for_black = printing::PRINTOUTMODE_NORMAL;
+  *color_model_for_color = PRINTOUTMODE_NORMAL;
+  *color_model_for_black = PRINTOUTMODE_NORMAL;
 
   // Check to see if NORMAL_GRAY value is supported by PrintoutMode.
   // If NORMAL_GRAY is not supported, NORMAL value is used to
   // represent grayscale. If NORMAL_GRAY is supported, NORMAL is used to
   // represent color.
-  if (ppdFindChoice(printout_mode, printing::kNormalGray))
-    *color_model_for_black = printing::PRINTOUTMODE_NORMAL_GRAY;
+  if (ppdFindChoice(printout_mode, kNormalGray))
+    *color_model_for_black = PRINTOUTMODE_NORMAL_GRAY;
 
   // Get the default marked choice to identify the default color setting
   // value.
@@ -192,12 +193,12 @@ bool GetPrintOutModeColorSettings(ppd_file_t* ppd,
   }
   if (printout_mode_choice) {
     if (base::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
-                                         printing::kNormalGray) ||
+                                         kNormalGray) ||
         base::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
                                          kHighGray) ||
         base::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
-                                          kDraftGray)) {
-      *color_model_for_black = printing::PRINTOUTMODE_NORMAL_GRAY;
+                                         kDraftGray)) {
+      *color_model_for_black = PRINTOUTMODE_NORMAL_GRAY;
       *color_is_default = false;
     }
   }
@@ -213,11 +214,11 @@ bool GetColorModeSettings(ppd_file_t* ppd,
   if (!color_mode_option)
     return false;
 
-  if (ppdFindChoice(color_mode_option, printing::kColor))
-    *color_model_for_color = printing::COLORMODE_COLOR;
+  if (ppdFindChoice(color_mode_option, kColor))
+    *color_model_for_color = COLORMODE_COLOR;
 
-  if (ppdFindChoice(color_mode_option, printing::kMonochrome))
-    *color_model_for_black = printing::COLORMODE_MONOCHROME;
+  if (ppdFindChoice(color_mode_option, kMonochrome))
+    *color_model_for_black = COLORMODE_MONOCHROME;
 
   ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kColorMode);
   if (!mode_choice) {
@@ -226,8 +227,8 @@ bool GetColorModeSettings(ppd_file_t* ppd,
   }
 
   if (mode_choice) {
-    *color_is_default = base::EqualsCaseInsensitiveASCII(
-        mode_choice->choice, printing::kColor);
+    *color_is_default =
+        base::EqualsCaseInsensitiveASCII(mode_choice->choice, kColor);
   }
   return true;
 }
@@ -237,14 +238,14 @@ bool GetHPColorSettings(ppd_file_t* ppd,
                         ColorModel* color_model_for_color,
                         bool* color_is_default) {
   // HP printers use "Color/Color Model" attribute in their ppds.
-  ppd_option_t* color_mode_option = ppdFindOption(ppd, printing::kColor);
+  ppd_option_t* color_mode_option = ppdFindOption(ppd, kColor);
   if (!color_mode_option)
     return false;
 
-  if (ppdFindChoice(color_mode_option, printing::kColor))
-    *color_model_for_color = printing::HP_COLOR_COLOR;
-  if (ppdFindChoice(color_mode_option, printing::kBlack))
-    *color_model_for_black = printing::HP_COLOR_BLACK;
+  if (ppdFindChoice(color_mode_option, kColor))
+    *color_model_for_color = HP_COLOR_COLOR;
+  if (ppdFindChoice(color_mode_option, kBlack))
+    *color_model_for_black = HP_COLOR_BLACK;
 
   ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kColorMode);
   if (!mode_choice) {
@@ -252,8 +253,8 @@ bool GetHPColorSettings(ppd_file_t* ppd,
                                 color_mode_option->defchoice);
   }
   if (mode_choice) {
-    *color_is_default = base::EqualsCaseInsensitiveASCII(
-        mode_choice->choice, printing::kColor);
+    *color_is_default =
+        base::EqualsCaseInsensitiveASCII(mode_choice->choice, kColor);
   }
   return true;
 }
@@ -267,13 +268,13 @@ bool GetProcessColorModelSettings(ppd_file_t* ppd,
   if (!color_mode_option)
     return false;
 
-  if (ppdFindChoice(color_mode_option, printing::kRGB))
-    *color_model_for_color = printing::PROCESSCOLORMODEL_RGB;
-  else if (ppdFindChoice(color_mode_option, printing::kCMYK))
-    *color_model_for_color = printing::PROCESSCOLORMODEL_CMYK;
+  if (ppdFindChoice(color_mode_option, kRGB))
+    *color_model_for_color = PROCESSCOLORMODEL_RGB;
+  else if (ppdFindChoice(color_mode_option, kCMYK))
+    *color_model_for_color = PROCESSCOLORMODEL_CMYK;
 
-  if (ppdFindChoice(color_mode_option, printing::kGreyscale))
-    *color_model_for_black = printing::PROCESSCOLORMODEL_GREYSCALE;
+  if (ppdFindChoice(color_mode_option, kGreyscale))
+    *color_model_for_black = PROCESSCOLORMODEL_GREYSCALE;
 
   ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kProcessColorModel);
   if (!mode_choice) {
@@ -282,8 +283,8 @@ bool GetProcessColorModelSettings(ppd_file_t* ppd,
   }
 
   if (mode_choice) {
-    *color_is_default = !base::EqualsCaseInsensitiveASCII(
-        mode_choice->choice, printing::kGreyscale);
+    *color_is_default =
+        !base::EqualsCaseInsensitiveASCII(mode_choice->choice, kGreyscale);
   }
   return true;
 }
@@ -293,7 +294,7 @@ bool GetColorModelSettings(ppd_file_t* ppd,
                            ColorModel* cm_color,
                            bool* is_color) {
   bool is_color_device = false;
-  ppd_attr_t* attr = ppdFindAttr(ppd, kColorDevice, NULL);
+  ppd_attr_t* attr = ppdFindAttr(ppd, kColorDevice, nullptr);
   if (attr && attr->value)
     is_color_device = ppd->color_device;
 
@@ -315,7 +316,7 @@ const int kDefaultIPPServerPort = 631;
 // functionality.
 HttpConnectionCUPS::HttpConnectionCUPS(const GURL& print_server_url,
                                        http_encryption_t encryption)
-    : http_(NULL) {
+    : http_(nullptr) {
   // If we have an empty url, use default print server.
   if (print_server_url.is_empty())
     return;
@@ -325,14 +326,14 @@ HttpConnectionCUPS::HttpConnectionCUPS(const GURL& print_server_url,
     port = kDefaultIPPServerPort;
 
   http_ = httpConnectEncrypt(print_server_url.host().c_str(), port, encryption);
-  if (http_ == NULL) {
+  if (!http_) {
     LOG(ERROR) << "CP_CUPS: Failed connecting to print server: "
                << print_server_url;
   }
 }
 
 HttpConnectionCUPS::~HttpConnectionCUPS() {
-  if (http_ != NULL)
+  if (http_)
     httpClose(http_);
 }
 
@@ -344,10 +345,9 @@ http_t* HttpConnectionCUPS::http() {
   return http_;
 }
 
-bool ParsePpdCapabilities(
-    const std::string& printer_name,
-    const std::string& printer_capabilities,
-    PrinterSemanticCapsAndDefaults* printer_info) {
+bool ParsePpdCapabilities(base::StringPiece printer_name,
+                          base::StringPiece printer_capabilities,
+                          PrinterSemanticCapsAndDefaults* printer_info) {
   base::FilePath ppd_file_path;
   if (!base::CreateTemporaryFile(&ppd_file_path))
     return false;
@@ -372,7 +372,7 @@ bool ParsePpdCapabilities(
   ppdMarkDefaults(ppd);
   MarkLpOptions(printer_name, &ppd);
 
-  printing::PrinterSemanticCapsAndDefaults caps;
+  PrinterSemanticCapsAndDefaults caps;
   caps.collate_capable = true;
   caps.collate_default = true;
   caps.copies_capable = true;
@@ -387,9 +387,9 @@ bool ParsePpdCapabilities(
   if (duplex_choice) {
     caps.duplex_capable = true;
     if (!base::EqualsCaseInsensitiveASCII(duplex_choice->choice, kDuplexNone))
-      caps.duplex_default = printing::LONG_EDGE;
+      caps.duplex_default = LONG_EDGE;
     else
-      caps.duplex_default = printing::SIMPLEX;
+      caps.duplex_default = SIMPLEX;
   }
 
   bool is_color = false;
diff --git a/chromium/printing/backend/cups_helper.h b/chromium/printing/backend/cups_helper.h
index 873f1ec2821..fd7601dc975 100644
--- a/chromium/printing/backend/cups_helper.h
+++ b/chromium/printing/backend/cups_helper.h
@@ -7,8 +7,7 @@
 
 #include <cups/cups.h>
 
-#include <string>
-
+#include "base/strings/string_piece.h"
 #include "printing/printing_export.h"
 
 class GURL;
@@ -37,8 +36,8 @@ class PRINTING_EXPORT HttpConnectionCUPS {
 // Helper function to parse and convert PPD capabilitites to
 // semantic options.
 PRINTING_EXPORT bool ParsePpdCapabilities(
-    const std::string& printer_name,
-    const std::string& printer_capabilities,
+    base::StringPiece printer_name,
+    base::StringPiece printer_capabilities,
     PrinterSemanticCapsAndDefaults* printer_info);
 
 }  // namespace printing
diff --git a/chromium/printing/backend/cups_helper_unittest.cc b/chromium/printing/backend/cups_helper_unittest.cc
index 01c5c65d364..3f601145f80 100644
--- a/chromium/printing/backend/cups_helper_unittest.cc
+++ b/chromium/printing/backend/cups_helper_unittest.cc
@@ -7,8 +7,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorDuplexLongEdge) {
-  std::string test_ppd_data;
-  test_ppd_data.append(
+  const char kTestPpdData[] =
       "*PPD-Adobe: \"4.3\"\n\n"
       "*OpenGroup: General/General\n\n"
       "*OpenUI *ColorModel/Color Model: PickOne\n"
@@ -29,10 +28,10 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorDuplexLongEdge) {
       "*Duplex DuplexTumble/ShortEdge: \""
       "<</Duplex true/Tumble true>>setpagedevice\"\n"
       "*CloseUI: *Duplex\n\n"
-      "*CloseGroup: General\n");
+      "*CloseGroup: General\n";
 
   printing::PrinterSemanticCapsAndDefaults caps;
-  EXPECT_TRUE(printing::ParsePpdCapabilities("test", test_ppd_data, &caps));
+  EXPECT_TRUE(printing::ParsePpdCapabilities("test", kTestPpdData, &caps));
   EXPECT_TRUE(caps.collate_capable);
   EXPECT_TRUE(caps.collate_default);
   EXPECT_TRUE(caps.copies_capable);
@@ -44,8 +43,7 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorDuplexLongEdge) {
 
 // Test duplex detection code, which regressed in http://crbug.com/103999.
 TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorDuplexSimples) {
-  std::string test_ppd_data;
-  test_ppd_data.append(
+  const char kTestPpdData[] =
       "*PPD-Adobe: \"4.3\"\n\n"
       "*OpenGroup: General/General\n\n"
       "*OpenUI *Duplex/Double-Sided Printing: PickOne\n"
@@ -57,10 +55,10 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorDuplexSimples) {
       "*Duplex DuplexTumble/Short Edge (Flip): "
       "\"<</Duplex true/Tumble true>>setpagedevice\"\n"
       "*CloseUI: *Duplex\n\n"
-      "*CloseGroup: General\n");
+      "*CloseGroup: General\n";
 
   printing::PrinterSemanticCapsAndDefaults caps;
-  EXPECT_TRUE(printing::ParsePpdCapabilities("test", test_ppd_data, &caps));
+  EXPECT_TRUE(printing::ParsePpdCapabilities("test", kTestPpdData, &caps));
   EXPECT_TRUE(caps.collate_capable);
   EXPECT_TRUE(caps.collate_default);
   EXPECT_TRUE(caps.copies_capable);
@@ -71,8 +69,7 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorDuplexSimples) {
 }
 
 TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorNoDuplex) {
-  std::string test_ppd_data;
-  test_ppd_data.append(
+  const char kTestPpdData[] =
       "*PPD-Adobe: \"4.3\"\n\n"
       "*OpenGroup: General/General\n\n"
       "*OpenUI *ColorModel/Color Model: PickOne\n"
@@ -84,10 +81,10 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorNoDuplex) {
       "<</cupsColorSpace 3/cupsColorOrder 0>>"
       "setpagedevice\"\n"
       "*CloseUI: *ColorModel\n"
-      "*CloseGroup: General\n");
+      "*CloseGroup: General\n";
 
   printing::PrinterSemanticCapsAndDefaults caps;
-  EXPECT_TRUE(printing::ParsePpdCapabilities("test", test_ppd_data, &caps));
+  EXPECT_TRUE(printing::ParsePpdCapabilities("test", kTestPpdData, &caps));
   EXPECT_TRUE(caps.collate_capable);
   EXPECT_TRUE(caps.collate_default);
   EXPECT_TRUE(caps.copies_capable);
@@ -98,8 +95,7 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingNoColorNoDuplex) {
 }
 
 TEST(PrintBackendCupsHelperTest, TestPpdParsingColorTrueDuplexLongEdge) {
-  std::string test_ppd_data;
-  test_ppd_data.append(
+  const char kTestPpdData[] =
       "*PPD-Adobe: \"4.3\"\n\n"
       "*ColorDevice: True\n"
       "*DefaultColorSpace: CMYK\n\n"
@@ -120,10 +116,10 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingColorTrueDuplexLongEdge) {
       "*Duplex DuplexTumble/ShortEdge: \""
       "<</Duplex true/Tumble true>>setpagedevice\"\n"
       "*CloseUI: *Duplex\n\n"
-      "*CloseGroup: General\n");
+      "*CloseGroup: General\n";
 
   printing::PrinterSemanticCapsAndDefaults caps;
-  EXPECT_TRUE(printing::ParsePpdCapabilities("test", test_ppd_data, &caps));
+  EXPECT_TRUE(printing::ParsePpdCapabilities("test", kTestPpdData, &caps));
   EXPECT_TRUE(caps.collate_capable);
   EXPECT_TRUE(caps.collate_default);
   EXPECT_TRUE(caps.copies_capable);
@@ -134,8 +130,7 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingColorTrueDuplexLongEdge) {
 }
 
 TEST(PrintBackendCupsHelperTest, TestPpdParsingColorFalseDuplexLongEdge) {
-  std::string test_ppd_data;
-  test_ppd_data.append(
+  const char kTestPpdData[] =
       "*PPD-Adobe: \"4.3\"\n\n"
       "*ColorDevice: True\n"
       "*DefaultColorSpace: CMYK\n\n"
@@ -160,10 +155,10 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingColorFalseDuplexLongEdge) {
       "*Duplex DuplexTumble/ShortEdge: \""
       "<</Duplex true/Tumble true>>setpagedevice\"\n"
       "*CloseUI: *Duplex\n\n"
-      "*CloseGroup: General\n");
+      "*CloseGroup: General\n";
 
   printing::PrinterSemanticCapsAndDefaults caps;
-  EXPECT_TRUE(printing::ParsePpdCapabilities("test", test_ppd_data, &caps));
+  EXPECT_TRUE(printing::ParsePpdCapabilities("test", kTestPpdData, &caps));
   EXPECT_TRUE(caps.collate_capable);
   EXPECT_TRUE(caps.collate_default);
   EXPECT_TRUE(caps.copies_capable);
@@ -174,8 +169,7 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingColorFalseDuplexLongEdge) {
 }
 
 TEST(PrintBackendCupsHelperTest, TestPpdParsingPageSize) {
-  std::string test_ppd_data;
-  test_ppd_data.append(
+  const char kTestPpdData[] =
       "*PPD-Adobe: \"4.3\"\n\n"
       "*OpenUI *PageSize: PickOne\n"
       "*OrderDependency: 30 AnySetup *PageSize\n"
@@ -191,10 +185,10 @@ TEST(PrintBackendCupsHelperTest, TestPpdParsingPageSize) {
       "*DefaultPaperDimension: Letter\n"
       "*PaperDimension Letter/US Letter: \"612   792\"\n"
       "*PaperDimension Legal/US Legal: \"612  1008\"\n\n"
-      "*CloseUI: *PageSize\n\n");
+      "*CloseUI: *PageSize\n\n";
 
   printing::PrinterSemanticCapsAndDefaults caps;
-  EXPECT_TRUE(printing::ParsePpdCapabilities("test", test_ppd_data, &caps));
+  EXPECT_TRUE(printing::ParsePpdCapabilities("test", kTestPpdData, &caps));
   ASSERT_EQ(2UL, caps.papers.size());
   EXPECT_EQ("Letter", caps.papers[0].vendor_id);
   EXPECT_EQ("US Letter", caps.papers[0].display_name);
diff --git a/chromium/printing/backend/print_backend.cc b/chromium/printing/backend/print_backend.cc
index 6c43b648f87..f17983778d7 100644
--- a/chromium/printing/backend/print_backend.cc
+++ b/chromium/printing/backend/print_backend.cc
@@ -26,6 +26,9 @@ PrinterSemanticCapsAndDefaults::PrinterSemanticCapsAndDefaults()
       bw_model(UNKNOWN_COLOR_MODEL)
 {}
 
+PrinterSemanticCapsAndDefaults::PrinterSemanticCapsAndDefaults(
+    const PrinterSemanticCapsAndDefaults& other) = default;
+
 PrinterSemanticCapsAndDefaults::~PrinterSemanticCapsAndDefaults() {}
 
 PrinterCapsAndDefaults::PrinterCapsAndDefaults() {}
diff --git a/chromium/printing/backend/print_backend.h b/chromium/printing/backend/print_backend.h
index 4fa8215084c..5086d204734 100644
--- a/chromium/printing/backend/print_backend.h
+++ b/chromium/printing/backend/print_backend.h
@@ -39,6 +39,7 @@ using PrinterList = std::vector<PrinterBasicInfo>;
 
 struct PRINTING_EXPORT PrinterSemanticCapsAndDefaults {
   PrinterSemanticCapsAndDefaults();
+  PrinterSemanticCapsAndDefaults(const PrinterSemanticCapsAndDefaults& other);
   ~PrinterSemanticCapsAndDefaults();
 
   bool collate_capable;
diff --git a/chromium/printing/emf_win.cc b/chromium/printing/emf_win.cc
index f00a669ccd6..ff1a5a52165 100644
--- a/chromium/printing/emf_win.cc
+++ b/chromium/printing/emf_win.cc
@@ -366,7 +366,7 @@ bool Emf::Record::SafePlayback(Emf::EnumerationContext* context) const {
         if (!DIBFormatNativelySupported(hdc, CHECKJPEGFORMAT, bits,
                                         bmih->biSizeImage)) {
           play_normally = false;
-          bitmap.reset(gfx::JPEGCodec::Decode(bits, bmih->biSizeImage));
+          bitmap = gfx::JPEGCodec::Decode(bits, bmih->biSizeImage);
         }
       } else if (bmih->biCompression == BI_PNG) {
         if (!DIBFormatNativelySupported(hdc, CHECKPNGFORMAT, bits,
diff --git a/chromium/printing/pdf_metafile_skia.cc b/chromium/printing/pdf_metafile_skia.cc
index d3679c4649b..27aa930549e 100644
--- a/chromium/printing/pdf_metafile_skia.cc
+++ b/chromium/printing/pdf_metafile_skia.cc
@@ -14,7 +14,6 @@
 #include "base/posix/eintr_wrapper.h"
 #include "base/time/time.h"
 #include "printing/print_settings.h"
-#include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkDocument.h"
@@ -157,17 +156,19 @@ bool PdfMetafileSkia::FinishDocument() {
     FinishPage();
 
   SkDynamicMemoryWStream pdf_stream;
-  skia::RefPtr<SkDocument> pdf_doc =
-      skia::AdoptRef(SkDocument::CreatePDF(&pdf_stream));
-  const std::string& user_agent = GetAgent();
-  SkDocument::Attribute info[] = {
-      SkDocument::Attribute(SkString("Creator"),
-                            user_agent.empty()
-                            ? SkString("Chromium")
-                            : SkString(user_agent.c_str(), user_agent.size())),
-  };
+
+  SkDocument::PDFMetadata metadata;
   SkTime::DateTime now = TimeToSkTime(base::Time::Now());
-  pdf_doc->setMetadata(info, SK_ARRAY_COUNT(info), &now, &now);
+  metadata.fCreation.fEnabled = true;
+  metadata.fCreation.fDateTime = now;
+  metadata.fModified.fEnabled = true;
+  metadata.fModified.fDateTime = now;
+  const std::string& agent = GetAgent();
+  metadata.fCreator = agent.empty() ? SkString("Chromium")
+                                    : SkString(agent.c_str(), agent.size());
+  sk_sp<SkDocument> pdf_doc = SkDocument::MakePDF(
+      &pdf_stream, SK_ScalarDefaultRasterDPI, metadata, nullptr, false);
+
   for (const auto& page : data_->pages_) {
     SkCanvas* canvas = pdf_doc->beginPage(
         page.page_size_.width(), page.page_size_.height(), &page.content_area_);
diff --git a/chromium/printing/pdf_render_settings.h b/chromium/printing/pdf_render_settings.h
index f8b1a656f8b..d00b97e0ebd 100644
--- a/chromium/printing/pdf_render_settings.h
+++ b/chromium/printing/pdf_render_settings.h
@@ -9,7 +9,7 @@
 #include "ipc/ipc_param_traits.h"
 #include "printing/printing_export.h"
 #include "ui/gfx/geometry/rect.h"
-#include "ui/gfx/ipc/gfx_param_traits.h"
+#include "ui/gfx/ipc/geometry/gfx_param_traits.h"
 #include "ui/gfx/ipc/skia/gfx_skia_param_traits.h"
 
 namespace printing {
diff --git a/chromium/printing/pdf_transform.cc b/chromium/printing/pdf_transform.cc
index f69116881d1..7555bd6c509 100644
--- a/chromium/printing/pdf_transform.cc
+++ b/chromium/printing/pdf_transform.cc
@@ -13,13 +13,13 @@ namespace printing {
 
 namespace {
 
-// When a ClipBox has top < bottom, or right < left, the values should be
+// When a PdfRectangle has top < bottom, or right < left, the values should be
 // swapped.
-void SwapClipBoxValuesIfNeeded(ClipBox* clip_box) {
-  if (clip_box->top < clip_box->bottom)
-    std::swap(clip_box->top, clip_box->bottom);
-  if (clip_box->right < clip_box->left)
-    std::swap(clip_box->right, clip_box->left);
+void SwapPdfRectangleValuesIfNeeded(PdfRectangle* rect) {
+  if (rect->top < rect->bottom)
+    std::swap(rect->top, rect->bottom);
+  if (rect->right < rect->left)
+    std::swap(rect->right, rect->left);
 }
 
 }  // namespace
@@ -40,7 +40,7 @@ double CalculateScaleFactor(const gfx::Rect& content_rect,
   return std::min(ratio_x, ratio_y);
 }
 
-void SetDefaultClipBox(bool rotated, ClipBox* clip_box) {
+void SetDefaultClipBox(bool rotated, PdfRectangle* clip_box) {
   const int kDpi = 72;
   const float kPaperWidth = 8.5 * kDpi;
   const float kPaperHeight = 11 * kDpi;
@@ -53,12 +53,12 @@ void SetDefaultClipBox(bool rotated, ClipBox* clip_box) {
 void CalculateMediaBoxAndCropBox(bool rotated,
                                  bool has_media_box,
                                  bool has_crop_box,
-                                 printing::ClipBox* media_box,
-                                 printing::ClipBox* crop_box) {
+                                 PdfRectangle* media_box,
+                                 PdfRectangle* crop_box) {
   if (has_media_box)
-    SwapClipBoxValuesIfNeeded(media_box);
+    SwapPdfRectangleValuesIfNeeded(media_box);
   if (has_crop_box)
-    SwapClipBoxValuesIfNeeded(crop_box);
+    SwapPdfRectangleValuesIfNeeded(crop_box);
 
   if (!has_media_box && !has_crop_box) {
     SetDefaultClipBox(rotated, crop_box);
@@ -70,28 +70,28 @@ void CalculateMediaBoxAndCropBox(bool rotated,
   }
 }
 
-ClipBox CalculateClipBoxBoundary(const ClipBox& media_box,
-                                 const ClipBox& crop_box) {
-  ClipBox clip_box;
+PdfRectangle CalculateClipBoxBoundary(const PdfRectangle& media_box,
+                                      const PdfRectangle& crop_box) {
+  PdfRectangle clip_box;
 
   // Clip |media_box| to the size of |crop_box|, but ignore |crop_box| if it is
   // bigger than |media_box|.
   clip_box.left = std::max(crop_box.left, media_box.left);
+  clip_box.bottom = std::max(crop_box.bottom, media_box.bottom);
   clip_box.right = std::min(crop_box.right, media_box.right);
   clip_box.top = std::min(crop_box.top, media_box.top);
-  clip_box.bottom = std::max(crop_box.bottom, media_box.bottom);
   return clip_box;
 }
 
-void ScaleClipBox(double scale_factor, ClipBox* box) {
-  box->left *= scale_factor;
-  box->right *= scale_factor;
-  box->bottom *= scale_factor;
-  box->top *= scale_factor;
+void ScalePdfRectangle(double scale_factor, PdfRectangle* rect) {
+  rect->left *= scale_factor;
+  rect->bottom *= scale_factor;
+  rect->right *= scale_factor;
+  rect->top *= scale_factor;
 }
 
 void CalculateScaledClipBoxOffset(const gfx::Rect& content_rect,
-                                  const ClipBox& source_clip_box,
+                                  const PdfRectangle& source_clip_box,
                                   double* offset_x,
                                   double* offset_y) {
   const float clip_box_width = source_clip_box.right - source_clip_box.left;
@@ -108,7 +108,7 @@ void CalculateNonScaledClipBoxOffset(const gfx::Rect& content_rect,
                                      int rotation,
                                      int page_width,
                                      int page_height,
-                                     const ClipBox& source_clip_box,
+                                     const PdfRectangle& source_clip_box,
                                      double* offset_x,
                                      double* offset_y) {
   // Align the intended clip region to left-top corner of real clip region.
diff --git a/chromium/printing/pdf_transform.h b/chromium/printing/pdf_transform.h
index 2cc244b1740..7910f0fc832 100644
--- a/chromium/printing/pdf_transform.h
+++ b/chromium/printing/pdf_transform.h
@@ -15,11 +15,11 @@ namespace printing {
 
 // A rect struct for use with FPDF bounding box functions.
 // With PDFs, origin is bottom-left.
-struct PRINTING_EXPORT ClipBox {
+struct PRINTING_EXPORT PdfRectangle {
   float left;
+  float bottom;
   float right;
   float top;
-  float bottom;
 };
 
 // Calculate the scale factor between |content_rect| and a page of size
@@ -38,7 +38,7 @@ PRINTING_EXPORT double CalculateScaleFactor(const gfx::Rect& content_rect,
 // Make the default size to be letter size (8.5" X 11"). We are just following
 // the PDFium way of handling these corner cases. PDFium always consider
 // US-Letter as the default page size.
-PRINTING_EXPORT void SetDefaultClipBox(bool rotated, ClipBox* clip_box);
+PRINTING_EXPORT void SetDefaultClipBox(bool rotated, PdfRectangle* clip_box);
 
 // Set the media box and/or crop box as needed. If both boxes are there, then
 // nothing needs to be done. If one box is missing, then fill it with the value
@@ -47,8 +47,8 @@ PRINTING_EXPORT void SetDefaultClipBox(bool rotated, ClipBox* clip_box);
 PRINTING_EXPORT void CalculateMediaBoxAndCropBox(bool rotated,
                                                  bool has_media_box,
                                                  bool has_crop_box,
-                                                 printing::ClipBox* media_box,
-                                                 printing::ClipBox* crop_box);
+                                                 PdfRectangle* media_box,
+                                                 PdfRectangle* crop_box);
 
 // Compute source clip box boundaries based on the crop box / media box of
 // source page and scale factor.
@@ -56,11 +56,12 @@ PRINTING_EXPORT void CalculateMediaBoxAndCropBox(bool rotated,
 //
 // |media_box| The PDF's media box.
 // |crop_box| The PDF's crop box.
-PRINTING_EXPORT ClipBox CalculateClipBoxBoundary(const ClipBox& media_box,
-                                                 const ClipBox& crop_box);
+PRINTING_EXPORT PdfRectangle CalculateClipBoxBoundary(
+    const PdfRectangle& media_box,
+    const PdfRectangle& crop_box);
 
 // Scale |box| by |scale_factor|.
-PRINTING_EXPORT void ScaleClipBox(double scale_factor, ClipBox* box);
+PRINTING_EXPORT void ScalePdfRectangle(double scale_factor, PdfRectangle* rect);
 
 // Calculate the clip box translation offset for a page that does need to be
 // scaled. All parameters are in points.
@@ -73,7 +74,7 @@ PRINTING_EXPORT void ScaleClipBox(double scale_factor, ClipBox* box);
 // source clip box, relative to origin at left-bottom.
 PRINTING_EXPORT void CalculateScaledClipBoxOffset(
     const gfx::Rect& content_rect,
-    const ClipBox& source_clip_box,
+    const PdfRectangle& source_clip_box,
     double* offset_x,
     double* offset_y);
 
@@ -95,7 +96,7 @@ PRINTING_EXPORT void CalculateNonScaledClipBoxOffset(
     int rotation,
     int page_width,
     int page_height,
-    const ClipBox& source_clip_box,
+    const PdfRectangle& source_clip_box,
     double* offset_x,
     double* offset_y);
 
diff --git a/chromium/printing/pdf_transform_unittest.cc b/chromium/printing/pdf_transform_unittest.cc
index e026ac45c2a..4ee2145b3a3 100644
--- a/chromium/printing/pdf_transform_unittest.cc
+++ b/chromium/printing/pdf_transform_unittest.cc
@@ -17,43 +17,44 @@ const float kDefaultHeight = 11.0 * kPointsPerInch;
 const float kDefaultRatio = kDefaultWidth / kDefaultHeight;
 const double kTolerance = 0.0001;
 
-void ExpectDefaultPortraitBox(const ClipBox& box) {
+void ExpectDefaultPortraitBox(const PdfRectangle& box) {
   EXPECT_FLOAT_EQ(0, box.left);
+  EXPECT_FLOAT_EQ(0, box.bottom);
   EXPECT_FLOAT_EQ(kDefaultWidth, box.right);
   EXPECT_FLOAT_EQ(kDefaultHeight, box.top);
-  EXPECT_FLOAT_EQ(0, box.bottom);
 }
 
-void ExpectDefaultLandscapeBox(const ClipBox& box) {
+void ExpectDefaultLandscapeBox(const PdfRectangle& box) {
   EXPECT_FLOAT_EQ(0, box.left);
+  EXPECT_FLOAT_EQ(0, box.bottom);
   EXPECT_FLOAT_EQ(kDefaultHeight, box.right);
   EXPECT_FLOAT_EQ(kDefaultWidth, box.top);
-  EXPECT_FLOAT_EQ(0, box.bottom);
 }
 
-void ExpectBoxesAreEqual(const ClipBox& expected, const ClipBox& actual) {
+void ExpectBoxesAreEqual(const PdfRectangle& expected,
+                         const PdfRectangle& actual) {
   EXPECT_FLOAT_EQ(expected.left, actual.left);
+  EXPECT_FLOAT_EQ(expected.bottom, actual.bottom);
   EXPECT_FLOAT_EQ(expected.right, actual.right);
   EXPECT_FLOAT_EQ(expected.top, actual.top);
-  EXPECT_FLOAT_EQ(expected.bottom, actual.bottom);
 }
 
-void InitializeBoxToInvalidValues(ClipBox* box) {
-  box->left = box->right = box->top = box->bottom = -1;
+void InitializeBoxToInvalidValues(PdfRectangle* box) {
+  box->left = box->bottom = box->right = box->top = -1;
 }
 
-void InitializeBoxToDefaultPortraitValues(ClipBox* box) {
+void InitializeBoxToDefaultPortraitValues(PdfRectangle* box) {
   box->left = 0;
+  box->bottom = 0;
   box->right = kDefaultWidth;
   box->top = kDefaultHeight;
-  box->bottom = 0;
 }
 
-void InitializeBoxToDefaultLandscapeValue(ClipBox* box) {
+void InitializeBoxToDefaultLandscapeValue(PdfRectangle* box) {
   box->left = 0;
+  box->bottom = 0;
   box->right = kDefaultHeight;
   box->top = kDefaultWidth;
-  box->bottom = 0;
 }
 
 }  // namespace
@@ -98,7 +99,7 @@ TEST(PdfTransformTest, CalculateScaleFactor) {
 }
 
 TEST(PdfTransformTest, SetDefaultClipBox) {
-  ClipBox box;
+  PdfRectangle box;
 
   SetDefaultClipBox(false, &box);
   ExpectDefaultPortraitBox(box);
@@ -108,8 +109,8 @@ TEST(PdfTransformTest, SetDefaultClipBox) {
 }
 
 TEST(PdfTransformTest, CalculateMediaBoxAndCropBox) {
-  ClipBox media_box;
-  ClipBox crop_box;
+  PdfRectangle media_box;
+  PdfRectangle crop_box;
 
   // Assume both boxes are there.
   InitializeBoxToDefaultPortraitValues(&media_box);
@@ -129,11 +130,7 @@ TEST(PdfTransformTest, CalculateMediaBoxAndCropBox) {
   ExpectDefaultLandscapeBox(crop_box);
 
   // Assume crop box is missing.
-  ClipBox expected_box;
-  expected_box.left = 0;
-  expected_box.right = 42;
-  expected_box.top = 420;
-  expected_box.bottom = 0;
+  const PdfRectangle expected_box = {0, 0, 42, 420};
   media_box = expected_box;
   InitializeBoxToInvalidValues(&crop_box);
   CalculateMediaBoxAndCropBox(false, true, false, &media_box, &crop_box);
@@ -148,9 +145,9 @@ TEST(PdfTransformTest, CalculateMediaBoxAndCropBox) {
 }
 
 TEST(PdfTransformTest, CalculateClipBoxBoundary) {
-  ClipBox media_box;
-  ClipBox crop_box;
-  ClipBox result;
+  PdfRectangle media_box;
+  PdfRectangle crop_box;
+  PdfRectangle result;
 
   // media box and crop box are the same.
   InitializeBoxToDefaultPortraitValues(&media_box);
@@ -162,37 +159,37 @@ TEST(PdfTransformTest, CalculateClipBoxBoundary) {
   InitializeBoxToDefaultLandscapeValue(&crop_box);
   result = CalculateClipBoxBoundary(media_box, crop_box);
   EXPECT_FLOAT_EQ(0, result.left);
+  EXPECT_FLOAT_EQ(0, result.bottom);
   EXPECT_FLOAT_EQ(kDefaultWidth, result.right);
   EXPECT_FLOAT_EQ(kDefaultWidth, result.top);
-  EXPECT_FLOAT_EQ(0, result.bottom);
 
   // crop box is smaller than media box.
   crop_box.left = 0;
-  crop_box.right = 100;
   crop_box.bottom = 0;
+  crop_box.right = 100;
   crop_box.top = 200;
   result = CalculateClipBoxBoundary(media_box, crop_box);
   EXPECT_FLOAT_EQ(0, result.left);
+  EXPECT_FLOAT_EQ(0, result.bottom);
   EXPECT_FLOAT_EQ(100, result.right);
   EXPECT_FLOAT_EQ(200, result.top);
-  EXPECT_FLOAT_EQ(0, result.bottom);
 
   // crop box is smaller than the media box in one dimension and longer in the
   // other.
   crop_box.left = 0;
-  crop_box.right = 100;
   crop_box.bottom = 0;
+  crop_box.right = 100;
   crop_box.top = 2000;
   result = CalculateClipBoxBoundary(media_box, crop_box);
   EXPECT_FLOAT_EQ(0, result.left);
+  EXPECT_FLOAT_EQ(0, result.bottom);
   EXPECT_FLOAT_EQ(100, result.right);
   EXPECT_FLOAT_EQ(kDefaultHeight, result.top);
-  EXPECT_FLOAT_EQ(0, result.bottom);
 }
 
 TEST(PdfTransformTest, CalculateScaledClipBoxOffset) {
   const gfx::Rect rect(kDefaultWidth, kDefaultHeight);
-  ClipBox clip_box;
+  PdfRectangle clip_box;
   double offset_x;
   double offset_y;
 
@@ -214,7 +211,7 @@ TEST(PdfTransformTest, CalculateNonScaledClipBoxOffset) {
   int page_width = kDefaultWidth;
   int page_height = kDefaultHeight;
   const gfx::Rect rect(kDefaultWidth, kDefaultHeight);
-  ClipBox clip_box;
+  PdfRectangle clip_box;
   double offset_x;
   double offset_y;
 
@@ -284,12 +281,12 @@ TEST(PdfTransformTest, ReversedMediaBox) {
   int page_width = kDefaultWidth;
   int page_height = kDefaultHeight;
   const gfx::Rect rect(kDefaultWidth, kDefaultHeight);
-  ClipBox clip_box;
+  PdfRectangle clip_box;
   double offset_x;
   double offset_y;
 
-  const ClipBox expected_media_box_b491160 = {0, 612, 0, -792};
-  ClipBox media_box_b491160 = {0, 612, -792, 0};
+  const PdfRectangle expected_media_box_b491160 = {0, -792, 612, 0};
+  PdfRectangle media_box_b491160 = {0, 0, 612, -792};
   CalculateMediaBoxAndCropBox(false, true, false, &media_box_b491160,
                               &clip_box);
   ExpectBoxesAreEqual(expected_media_box_b491160, media_box_b491160);
@@ -304,7 +301,7 @@ TEST(PdfTransformTest, ReversedMediaBox) {
   EXPECT_DOUBLE_EQ(0, offset_x);
   EXPECT_DOUBLE_EQ(792, offset_y);
 
-  ClipBox media_box_b588757 = {0, 612, 0, 792};
+  PdfRectangle media_box_b588757 = {0, 792, 612, 0};
   CalculateMediaBoxAndCropBox(false, true, false, &media_box_b588757,
                               &clip_box);
   ExpectDefaultPortraitBox(media_box_b588757);
@@ -319,7 +316,7 @@ TEST(PdfTransformTest, ReversedMediaBox) {
   EXPECT_DOUBLE_EQ(0, offset_x);
   EXPECT_DOUBLE_EQ(0, offset_y);
 
-  ClipBox media_box_left_right_flipped = {612, 0, 0, 792};
+  PdfRectangle media_box_left_right_flipped = {612, 792, 0, 0};
   CalculateMediaBoxAndCropBox(false, true, false, &media_box_left_right_flipped,
                               &clip_box);
   ExpectDefaultPortraitBox(media_box_left_right_flipped);