diff --git a/android_webview/browser/aw_pdf_exporter.cc b/android_webview/browser/aw_pdf_exporter.cc
index 49007650a75b06..c944137b496262 100644
--- a/android_webview/browser/aw_pdf_exporter.cc
+++ b/android_webview/browser/aw_pdf_exporter.cc
@@ -4,6 +4,10 @@
 
 #include "android_webview/browser/aw_pdf_exporter.h"
 
+#include <memory>
+#include <utility>
+#include <vector>
+
 #include "android_webview/browser/aw_print_manager.h"
 #include "android_webview/native_jni/AwPdfExporter_jni.h"
 #include "base/android/jni_android.h"
@@ -60,12 +64,13 @@ void AwPdfExporter::ExportToPdf(JNIEnv* env,
                                 const JavaParamRef<jintArray>& pages,
                                 const JavaParamRef<jobject>& cancel_signal) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  printing::PrintSettings print_settings;
+  auto print_settings = std::make_unique<printing::PrintSettings>();
   printing::PageRanges page_ranges;
   JNI_AwPdfExporter_GetPageRanges(env, pages, &page_ranges);
-  InitPdfSettings(env, obj, page_ranges, print_settings);
+  // TODO(crbug.com/964948) make InitPdfSettings() return PrintSettings.
+  InitPdfSettings(env, obj, page_ranges, print_settings.get());
   AwPrintManager* print_manager = AwPrintManager::CreateForWebContents(
-      web_contents_, print_settings, fd,
+      web_contents_, std::move(print_settings), fd,
       base::Bind(&AwPdfExporter::DidExportPdf, base::Unretained(this)));
 
   if (!print_manager->PrintNow())
@@ -82,7 +87,7 @@ int MilsToDots(int val, int dpi) {
 void AwPdfExporter::InitPdfSettings(JNIEnv* env,
                                     const JavaRef<jobject>& obj,
                                     const printing::PageRanges& page_ranges,
-                                    printing::PrintSettings& settings) {
+                                    printing::PrintSettings* settings) {
   int dpi = Java_AwPdfExporter_getDpi(env, obj);
   int width = Java_AwPdfExporter_getPageWidth(env, obj);
   int height = Java_AwPdfExporter_getPageHeight(env, obj);
@@ -96,13 +101,13 @@ void AwPdfExporter::InitPdfSettings(JNIEnv* env,
   printable_area_device_units.SetRect(0, 0, width_in_dots, height_in_dots);
 
   if (!page_ranges.empty())
-    settings.set_ranges(page_ranges);
+    settings->set_ranges(page_ranges);
 
-  settings.set_dpi(dpi);
+  settings->set_dpi(dpi);
   // TODO(sgurun) verify that the value for newly added parameter for
   // (i.e. landscape_needs_flip) is correct.
-  settings.SetPrinterPrintableArea(physical_size_device_units,
-                                   printable_area_device_units, true);
+  settings->SetPrinterPrintableArea(physical_size_device_units,
+                                    printable_area_device_units, true);
 
   printing::PageMargins margins;
   margins.left = MilsToDots(Java_AwPdfExporter_getLeftMargin(env, obj), dpi);
@@ -110,8 +115,8 @@ void AwPdfExporter::InitPdfSettings(JNIEnv* env,
   margins.top = MilsToDots(Java_AwPdfExporter_getTopMargin(env, obj), dpi);
   margins.bottom =
       MilsToDots(Java_AwPdfExporter_getBottomMargin(env, obj), dpi);
-  settings.SetCustomMargins(margins);
-  settings.set_should_print_backgrounds(true);
+  settings->SetCustomMargins(margins);
+  settings->set_should_print_backgrounds(true);
 }
 
 void AwPdfExporter::DidExportPdf(int page_count) {
diff --git a/android_webview/browser/aw_pdf_exporter.h b/android_webview/browser/aw_pdf_exporter.h
index 4735aaaaf882b1..587d2fae7f5641 100644
--- a/android_webview/browser/aw_pdf_exporter.h
+++ b/android_webview/browser/aw_pdf_exporter.h
@@ -39,7 +39,7 @@ class AwPdfExporter {
   void InitPdfSettings(JNIEnv* env,
                        const base::android::JavaRef<jobject>& obj,
                        const printing::PageRanges& page_ranges,
-                       printing::PrintSettings& settings);
+                       printing::PrintSettings* settings);
   void DidExportPdf(int page_count);
 
   JavaObjectWeakGlobalRef java_ref_;
diff --git a/android_webview/browser/aw_print_manager.cc b/android_webview/browser/aw_print_manager.cc
index 89bbbc9081e156..5c9d4dcd306b8f 100644
--- a/android_webview/browser/aw_print_manager.cc
+++ b/android_webview/browser/aw_print_manager.cc
@@ -4,6 +4,8 @@
 
 #include "android_webview/browser/aw_print_manager.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
@@ -36,20 +38,24 @@ int SaveDataToFd(int fd,
 // static
 AwPrintManager* AwPrintManager::CreateForWebContents(
     content::WebContents* contents,
-    const printing::PrintSettings& settings,
+    std::unique_ptr<printing::PrintSettings> settings,
     int file_descriptor,
     PrintManager::PdfWritingDoneCallback callback) {
   AwPrintManager* print_manager = new AwPrintManager(
-      contents, settings, file_descriptor, std::move(callback));
+      contents, std::move(settings), file_descriptor, std::move(callback));
   contents->SetUserData(UserDataKey(), base::WrapUnique(print_manager));
   return print_manager;
 }
 
-AwPrintManager::AwPrintManager(content::WebContents* contents,
-                               const printing::PrintSettings& settings,
-                               int file_descriptor,
-                               PdfWritingDoneCallback callback)
-    : PrintManager(contents), settings_(settings), fd_(file_descriptor) {
+AwPrintManager::AwPrintManager(
+    content::WebContents* contents,
+    std::unique_ptr<printing::PrintSettings> settings,
+    int file_descriptor,
+    PdfWritingDoneCallback callback)
+    : PrintManager(contents),
+      settings_(std::move(settings)),
+      fd_(file_descriptor) {
+  DCHECK(settings_);
   pdf_writing_done_callback_ = std::move(callback);
   cookie_ = 1;  // Set a valid dummy cookie value.
 }
@@ -75,7 +81,7 @@ void AwPrintManager::OnGetDefaultPrintSettings(
   // Unlike the printing_message_filter, we do process this in UI thread.
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   PrintMsg_Print_Params params;
-  printing::RenderParamsFromPrintSettings(settings_, &params);
+  printing::RenderParamsFromPrintSettings(*settings_, &params);
   params.document_cookie = cookie_;
   PrintHostMsg_GetDefaultPrintSettings::WriteReplyParams(reply_msg, params);
   render_frame_host->Send(reply_msg);
@@ -87,9 +93,9 @@ void AwPrintManager::OnScriptedPrint(
     IPC::Message* reply_msg) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   PrintMsg_PrintPages_Params params;
-  printing::RenderParamsFromPrintSettings(settings_, &params.params);
+  printing::RenderParamsFromPrintSettings(*settings_, &params.params);
   params.params.document_cookie = scripted_params.cookie;
-  params.pages = printing::PageRange::GetPages(settings_.ranges());
+  params.pages = printing::PageRange::GetPages(settings_->ranges());
   PrintHostMsg_ScriptedPrint::WriteReplyParams(reply_msg, params);
   render_frame_host->Send(reply_msg);
 }
diff --git a/android_webview/browser/aw_print_manager.h b/android_webview/browser/aw_print_manager.h
index 80b143053e54be..66094969aa6394 100644
--- a/android_webview/browser/aw_print_manager.h
+++ b/android_webview/browser/aw_print_manager.h
@@ -5,6 +5,8 @@
 #ifndef ANDROID_WEBVIEW_BROWSER_AW_PRINT_MANAGER_H_
 #define ANDROID_WEBVIEW_BROWSER_AW_PRINT_MANAGER_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "components/printing/browser/print_manager.h"
 #include "components/printing/common/print_messages.h"
@@ -21,7 +23,7 @@ class AwPrintManager : public printing::PrintManager,
   // The returned pointer is owned by |contents|.
   static AwPrintManager* CreateForWebContents(
       content::WebContents* contents,
-      const printing::PrintSettings& settings,
+      std::unique_ptr<printing::PrintSettings> settings,
       int file_descriptor,
       PdfWritingDoneCallback callback);
 
@@ -36,7 +38,7 @@ class AwPrintManager : public printing::PrintManager,
   friend class content::WebContentsUserData<AwPrintManager>;
 
   AwPrintManager(content::WebContents* contents,
-                 const printing::PrintSettings& settings,
+                 std::unique_ptr<printing::PrintSettings> settings,
                  int file_descriptor,
                  PdfWritingDoneCallback callback);
 
@@ -50,7 +52,7 @@ class AwPrintManager : public printing::PrintManager,
                        const PrintHostMsg_ScriptedPrint_Params& params,
                        IPC::Message* reply_msg) override;
 
-  printing::PrintSettings settings_;
+  const std::unique_ptr<printing::PrintSettings> settings_;
 
   // The file descriptor into which the PDF of the document will be written.
   int fd_;
diff --git a/chrome/browser/printing/print_job.cc b/chrome/browser/printing/print_job.cc
index 4324f93b7087ab..efb419d34face2 100644
--- a/chrome/browser/printing/print_job.cc
+++ b/chrome/browser/printing/print_job.cc
@@ -61,21 +61,21 @@ void PrintJob::Initialize(std::unique_ptr<PrinterQuery> query,
   DCHECK(!document_);
   worker_ = query->DetachWorker();
   worker_->SetPrintJob(this);
-  const PrintSettings& settings = query->settings();
-
-  auto new_doc =
-      base::MakeRefCounted<PrintedDocument>(settings, name, query->cookie());
-  new_doc->set_page_count(page_count);
-  UpdatePrintedDocument(new_doc);
+  std::unique_ptr<PrintSettings> settings = query->ExtractSettings();
 
 #if defined(OS_WIN)
-  pdf_page_mapping_ = PageRange::GetPages(settings.ranges());
+  pdf_page_mapping_ = PageRange::GetPages(settings->ranges());
   if (pdf_page_mapping_.empty()) {
     for (int i = 0; i < page_count; i++)
       pdf_page_mapping_.push_back(i);
   }
 #endif
 
+  auto new_doc = base::MakeRefCounted<PrintedDocument>(std::move(settings),
+                                                       name, query->cookie());
+  new_doc->set_page_count(page_count);
+  UpdatePrintedDocument(new_doc);
+
   // Don't forget to register to our own messages.
   registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
                  content::Source<PrintJob>(this));
diff --git a/chrome/browser/printing/print_job_unittest.cc b/chrome/browser/printing/print_job_unittest.cc
index bd50607d5e0952..71811d5def1f52 100644
--- a/chrome/browser/printing/print_job_unittest.cc
+++ b/chrome/browser/printing/print_job_unittest.cc
@@ -39,7 +39,7 @@ class TestQuery : public PrinterQuery {
                      content::ChildProcessHost::kInvalidUniqueID) {}
 
   void GetSettingsDone(base::OnceClosure callback,
-                       const PrintSettings& new_settings,
+                       std::unique_ptr<PrintSettings> new_settings,
                        PrintingContext::Result result) override {
     FAIL();
   }
@@ -57,16 +57,12 @@ class TestQuery : public PrinterQuery {
     auto worker = std::make_unique<TestPrintJobWorker>();
     EXPECT_TRUE(worker->Start());
     worker->printing_context()->UseDefaultSettings();
-    settings_ = worker->printing_context()->settings();
+    SetSettingsForTest(worker->printing_context()->TakeAndResetSettings());
 
     return std::move(worker);
   }
 
-  const PrintSettings& settings() const override { return settings_; }
-
  private:
-  PrintSettings settings_;
-
   DISALLOW_COPY_AND_ASSIGN(TestQuery);
 };
 
diff --git a/chrome/browser/printing/print_job_worker.cc b/chrome/browser/printing/print_job_worker.cc
index 72a0c8cd0f1be0..13f9d7af3ae796 100644
--- a/chrome/browser/printing/print_job_worker.cc
+++ b/chrome/browser/printing/print_job_worker.cc
@@ -221,7 +221,7 @@ void PrintJobWorker::UpdatePrintSettingsFromPOD(
 
 void PrintJobWorker::GetSettingsDone(SettingsCallback callback,
                                      PrintingContext::Result result) {
-  std::move(callback).Run(printing_context_->settings(), result);
+  std::move(callback).Run(printing_context_->TakeAndResetSettings(), result);
 }
 
 void PrintJobWorker::GetSettingsWithUI(int document_page_count,
diff --git a/chrome/browser/printing/print_job_worker.h b/chrome/browser/printing/print_job_worker.h
index d5711196e32cc2..4b3557e59419af 100644
--- a/chrome/browser/printing/print_job_worker.h
+++ b/chrome/browser/printing/print_job_worker.h
@@ -32,7 +32,8 @@ class PrintedPage;
 class PrintJobWorker {
  public:
   using SettingsCallback =
-      base::OnceCallback<void(const PrintSettings&, PrintingContext::Result)>;
+      base::OnceCallback<void(std::unique_ptr<PrintSettings>,
+                              PrintingContext::Result)>;
 
   PrintJobWorker(int render_process_id, int render_frame_id);
   virtual ~PrintJobWorker();
diff --git a/chrome/browser/printing/printer_query.cc b/chrome/browser/printing/printer_query.cc
index 3ea696aececf60..db7ee262b811c4 100644
--- a/chrome/browser/printing/printer_query.cc
+++ b/chrome/browser/printing/printer_query.cc
@@ -37,13 +37,13 @@ PrinterQuery::~PrinterQuery() {
 }
 
 void PrinterQuery::GetSettingsDone(base::OnceClosure callback,
-                                   const PrintSettings& new_settings,
+                                   std::unique_ptr<PrintSettings> new_settings,
                                    PrintingContext::Result result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   is_print_dialog_box_shown_ = false;
   last_status_ = result;
   if (result != PrintingContext::FAILED) {
-    settings_ = new_settings;
+    settings_ = std::move(new_settings);
     cookie_ = PrintSettings::NewCookie();
   } else {
     // Failure.
@@ -53,14 +53,15 @@ void PrinterQuery::GetSettingsDone(base::OnceClosure callback,
   std::move(callback).Run();
 }
 
-void PrinterQuery::PostSettingsDoneToIO(base::OnceClosure callback,
-                                        const PrintSettings& new_settings,
-                                        PrintingContext::Result result) {
+void PrinterQuery::PostSettingsDoneToIO(
+    base::OnceClosure callback,
+    std::unique_ptr<PrintSettings> new_settings,
+    PrintingContext::Result result) {
   // |this| is owned by |callback|, so |base::Unretained()| is safe.
   base::PostTask(
       FROM_HERE, {content::BrowserThread::IO},
       base::BindOnce(&PrinterQuery::GetSettingsDone, base::Unretained(this),
-                     std::move(callback), new_settings, result));
+                     std::move(callback), std::move(new_settings), result));
 }
 
 std::unique_ptr<PrintJobWorker> PrinterQuery::DetachWorker() {
@@ -71,7 +72,15 @@ std::unique_ptr<PrintJobWorker> PrinterQuery::DetachWorker() {
 }
 
 const PrintSettings& PrinterQuery::settings() const {
-  return settings_;
+  return *settings_;
+}
+
+std::unique_ptr<PrintSettings> PrinterQuery::ExtractSettings() {
+  return std::move(settings_);
+}
+
+void PrinterQuery::SetSettingsForTest(std::unique_ptr<PrintSettings> settings) {
+  settings_ = std::move(settings);
 }
 
 int PrinterQuery::cookie() const {
diff --git a/chrome/browser/printing/printer_query.h b/chrome/browser/printing/printer_query.h
index 03047d9a425b6d..00cf15c8b8d516 100644
--- a/chrome/browser/printing/printer_query.h
+++ b/chrome/browser/printing/printer_query.h
@@ -41,8 +41,9 @@ class PrinterQuery {
   // TODO(thestig): Do |worker_| and |callback_| need locks?
   virtual std::unique_ptr<PrintJobWorker> DetachWorker();
 
-  // Virtual so that tests can override.
-  virtual const PrintSettings& settings() const;
+  const PrintSettings& settings() const;
+
+  std::unique_ptr<PrintSettings> ExtractSettings();
 
   // Initializes the printing context. It is fine to call this function multiple
   // times to reinitialize the settings. |web_contents_observer| can be queried
@@ -84,19 +85,21 @@ class PrinterQuery {
  protected:
   // Virtual so that tests can override.
   virtual void GetSettingsDone(base::OnceClosure callback,
-                               const PrintSettings& new_settings,
+                               std::unique_ptr<PrintSettings> new_settings,
                                PrintingContext::Result result);
 
   void PostSettingsDoneToIO(base::OnceClosure callback,
-                            const PrintSettings& new_settings,
+                            std::unique_ptr<PrintSettings> new_settings,
                             PrintingContext::Result result);
 
+  void SetSettingsForTest(std::unique_ptr<PrintSettings> settings);
+
  private:
   // Lazy create the worker thread. There is one worker thread per print job.
   void StartWorker();
 
   // Cache of the print context settings for access in the UI thread.
-  PrintSettings settings_;
+  std::unique_ptr<PrintSettings> settings_;
 
   // Is the Print... dialog box currently shown.
   bool is_print_dialog_box_shown_ = false;
diff --git a/chrome/browser/printing/test_print_job.cc b/chrome/browser/printing/test_print_job.cc
index 29bd1a4aa2f6c3..ccf0dc10570f34 100644
--- a/chrome/browser/printing/test_print_job.cc
+++ b/chrome/browser/printing/test_print_job.cc
@@ -24,7 +24,7 @@ void TestPrintJob::Initialize(std::unique_ptr<PrinterQuery> query,
   std::unique_ptr<PrintJobWorker> worker = query->DetachWorker();
 
   scoped_refptr<PrintedDocument> new_doc =
-      base::MakeRefCounted<PrintedDocument>(query->settings(), name,
+      base::MakeRefCounted<PrintedDocument>(query->ExtractSettings(), name,
                                             query->cookie());
 
   new_doc->set_page_count(page_count);
diff --git a/chrome/browser/printing/test_printer_query.cc b/chrome/browser/printing/test_printer_query.cc
index 8049255aa3fde4..b1e6d24d7e8443 100644
--- a/chrome/browser/printing/test_printer_query.cc
+++ b/chrome/browser/printing/test_printer_query.cc
@@ -52,27 +52,27 @@ void TestPrinterQuery::SetSettings(base::Value new_settings,
 #if defined(OS_WIN)
   DCHECK(printer_type_);
 #endif
-  PrintSettings settings;
+  auto settings = std::make_unique<PrintSettings>();
   PrintingContext::Result result =
-      PrintSettingsFromJobSettings(new_settings, &settings)
+      PrintSettingsFromJobSettings(new_settings, settings.get())
           ? PrintingContext::OK
           : PrintingContext::FAILED;
 
   float device_microns_per_device_unit =
-      static_cast<float>(kMicronsPerInch) / settings.device_units_per_inch();
+      static_cast<float>(kMicronsPerInch) / settings->device_units_per_inch();
   gfx::Size paper_size =
-      gfx::Size(settings.requested_media().size_microns.width() /
+      gfx::Size(settings->requested_media().size_microns.width() /
                     device_microns_per_device_unit,
-                settings.requested_media().size_microns.height() /
+                settings->requested_media().size_microns.height() /
                     device_microns_per_device_unit);
   gfx::Rect paper_rect(0, 0, paper_size.width(), paper_size.height());
   paper_rect.Inset(offsets_->x(), offsets_->y());
-  settings.SetPrinterPrintableArea(paper_size, paper_rect, true);
+  settings->SetPrinterPrintableArea(paper_size, paper_rect, true);
 #if defined(OS_WIN)
-  settings.set_printer_type(*printer_type_);
+  settings->set_printer_type(*printer_type_);
 #endif
 
-  GetSettingsDone(std::move(callback), settings, result);
+  GetSettingsDone(std::move(callback), std::move(settings), result);
 }
 
 #if defined(OS_WIN)
diff --git a/chrome/browser/ui/libgtkui/print_dialog_gtk.cc b/chrome/browser/ui/libgtkui/print_dialog_gtk.cc
index 383b065b6ca218..93b3e514b585ce 100644
--- a/chrome/browser/ui/libgtkui/print_dialog_gtk.cc
+++ b/chrome/browser/ui/libgtkui/print_dialog_gtk.cc
@@ -213,11 +213,11 @@ void PrintDialogGtk::UseDefaultSettings() {
   gtk_settings_ = gtk_print_settings_copy(GetLastUsedSettings().settings());
   page_setup_ = gtk_page_setup_new();
 
-  PrintSettings settings;
-  InitPrintSettings(&settings);
+  InitPrintSettings(std::make_unique<PrintSettings>());
 }
 
-void PrintDialogGtk::UpdateSettings(printing::PrintSettings* settings) {
+void PrintDialogGtk::UpdateSettings(
+    std::unique_ptr<printing::PrintSettings> settings) {
   if (!gtk_settings_)
     gtk_settings_ = gtk_print_settings_copy(GetLastUsedSettings().settings());
 
@@ -305,7 +305,7 @@ void PrintDialogGtk::UpdateSettings(printing::PrintSettings* settings) {
       gtk_settings_, settings->landscape() ? GTK_PAGE_ORIENTATION_LANDSCAPE
                                            : GTK_PAGE_ORIENTATION_PORTRAIT);
 
-  InitPrintSettings(settings);
+  InitPrintSettings(std::move(settings));
 }
 
 void PrintDialogGtk::ShowDialog(
@@ -463,12 +463,12 @@ void PrintDialogGtk::OnResponse(GtkWidget* dialog, int response_id) {
           break;
       }
 
-      PrintSettings settings;
-      settings.set_is_modifiable(context_->settings().is_modifiable());
-      settings.set_ranges(ranges_vector);
-      settings.set_selection_only(print_selection_only);
-      InitPrintSettingsGtk(gtk_settings_, page_setup_, &settings);
-      context_->InitWithSettings(settings);
+      auto settings = std::make_unique<PrintSettings>();
+      settings->set_is_modifiable(context_->settings().is_modifiable());
+      settings->set_ranges(ranges_vector);
+      settings->set_selection_only(print_selection_only);
+      InitPrintSettingsGtk(gtk_settings_, page_setup_, settings.get());
+      context_->InitWithSettings(std::move(settings));
       std::move(callback_).Run(PrintingContextLinux::OK);
       return;
     }
@@ -528,9 +528,10 @@ void PrintDialogGtk::OnJobCompleted(GtkPrintJob* print_job,
   Release();
 }
 
-void PrintDialogGtk::InitPrintSettings(PrintSettings* settings) {
-  InitPrintSettingsGtk(gtk_settings_, page_setup_, settings);
-  context_->InitWithSettings(*settings);
+void PrintDialogGtk::InitPrintSettings(
+    std::unique_ptr<PrintSettings> settings) {
+  InitPrintSettingsGtk(gtk_settings_, page_setup_, settings.get());
+  context_->InitWithSettings(std::move(settings));
 }
 
 void PrintDialogGtk::OnWindowDestroying(aura::Window* window) {
diff --git a/chrome/browser/ui/libgtkui/print_dialog_gtk.h b/chrome/browser/ui/libgtkui/print_dialog_gtk.h
index 08d1f1762d2d3d..2522b8c9863049 100644
--- a/chrome/browser/ui/libgtkui/print_dialog_gtk.h
+++ b/chrome/browser/ui/libgtkui/print_dialog_gtk.h
@@ -7,6 +7,7 @@
 
 #include <gtk/gtk.h>
 #include <gtk/gtkunixprint.h>
+#include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
@@ -39,7 +40,8 @@ class PrintDialogGtk : public printing::PrintDialogGtkInterface,
 
   // printing::PrintDialogGtkInterface implementation.
   void UseDefaultSettings() override;
-  void UpdateSettings(printing::PrintSettings* settings) override;
+  void UpdateSettings(
+      std::unique_ptr<printing::PrintSettings> settings) override;
   void ShowDialog(
       gfx::NativeView parent_view,
       bool has_selection,
@@ -68,7 +70,7 @@ class PrintDialogGtk : public printing::PrintDialogGtkInterface,
 
   // Helper function for initializing |context_|'s PrintSettings with a given
   // |settings|.
-  void InitPrintSettings(printing::PrintSettings* settings);
+  void InitPrintSettings(std::unique_ptr<printing::PrintSettings> settings);
 
   // aura::WindowObserver implementation.
   void OnWindowDestroying(aura::Window* window) override;
diff --git a/printing/emf_win_unittest.cc b/printing/emf_win_unittest.cc
index d7395f59bd62aa..9be7d0e1f9a2d5 100644
--- a/printing/emf_win_unittest.cc
+++ b/printing/emf_win_unittest.cc
@@ -11,6 +11,7 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ -82,14 +83,15 @@ TEST_F(EmfPrintingTest, Enumerate) {
   if (IsTestCaseDisabled())
     return;
 
-  PrintSettings settings;
+  auto settings = std::make_unique<PrintSettings>();
 
   // My test case is a HP Color LaserJet 4550 PCL.
-  settings.set_device_name(L"UnitTest Printer");
+  settings->set_device_name(L"UnitTest Printer");
 
   // Initialize it.
   PrintingContextWin context(this);
-  EXPECT_EQ(PrintingContext::OK, context.InitWithSettingsForTest(settings));
+  EXPECT_EQ(PrintingContext::OK,
+            context.InitWithSettingsForTest(std::move(settings)));
 
   base::FilePath emf_file;
   EXPECT_TRUE(base::PathService::Get(base::DIR_SOURCE_ROOT, &emf_file));
diff --git a/printing/print_dialog_gtk_interface.h b/printing/print_dialog_gtk_interface.h
index 374acc46639229..439c04b7072cbd 100644
--- a/printing/print_dialog_gtk_interface.h
+++ b/printing/print_dialog_gtk_interface.h
@@ -5,6 +5,8 @@
 #ifndef PRINTING_PRINT_DIALOG_GTK_INTERFACE_H_
 #define PRINTING_PRINT_DIALOG_GTK_INTERFACE_H_
 
+#include <memory>
+
 #include "base/strings/string16.h"
 #include "printing/printing_context_linux.h"
 #include "ui/gfx/native_widget_types.h"
@@ -24,7 +26,7 @@ class PrintDialogGtkInterface {
 
   // Updates the dialog to use |settings|. Only used when printing without the
   // system print dialog. E.g. for Print Preview.
-  virtual void UpdateSettings(PrintSettings* settings) = 0;
+  virtual void UpdateSettings(std::unique_ptr<PrintSettings> settings) = 0;
 
   // Shows the dialog and handles the response with |callback|. Only used when
   // printing with the native print dialog.
diff --git a/printing/print_settings.cc b/printing/print_settings.cc
index bc221129807a8e..5cc1b554218ca5 100644
--- a/printing/print_settings.cc
+++ b/printing/print_settings.cc
@@ -153,8 +153,6 @@ PrintSettings::PrintSettings() {
   Clear();
 }
 
-PrintSettings::PrintSettings(const PrintSettings& other) = default;
-
 PrintSettings::~PrintSettings() = default;
 
 void PrintSettings::Clear() {
diff --git a/printing/print_settings.h b/printing/print_settings.h
index 3d9c3c5fa7eb48..47c0a636966fcd 100644
--- a/printing/print_settings.h
+++ b/printing/print_settings.h
@@ -8,6 +8,7 @@
 #include <algorithm>
 #include <string>
 
+#include "base/macros.h"
 #include "base/strings/string16.h"
 #include "printing/page_range.h"
 #include "printing/page_setup.h"
@@ -59,7 +60,6 @@ class PRINTING_EXPORT PrintSettings {
   };
 
   PrintSettings();
-  PrintSettings(const PrintSettings& other);
   ~PrintSettings();
 
   // Reinitialize the settings to the default values.
@@ -295,6 +295,8 @@ class PRINTING_EXPORT PrintSettings {
   // PIN code entered by the user.
   std::string pin_value_;
 #endif
+
+  DISALLOW_COPY_AND_ASSIGN(PrintSettings);
 };
 
 }  // namespace printing
diff --git a/printing/printed_document.cc b/printing/printed_document.cc
index 1f3c0c0b1bf778..3d974c5e4183d9 100644
--- a/printing/printed_document.cc
+++ b/printing/printed_document.cc
@@ -103,16 +103,16 @@ void DebugDumpSettings(const base::string16& doc_name,
 
 }  // namespace
 
-PrintedDocument::PrintedDocument(const PrintSettings& settings,
+PrintedDocument::PrintedDocument(std::unique_ptr<PrintSettings> settings,
                                  const base::string16& name,
                                  int cookie)
-    : immutable_(settings, name, cookie) {
+    : immutable_(std::move(settings), name, cookie) {
   // If there is a range, set the number of page
-  for (const PageRange& range : settings.ranges())
+  for (const PageRange& range : immutable_.settings_->ranges())
     mutable_.expected_page_count_ += range.to - range.from + 1;
 
   if (HasDebugDumpPath())
-    DebugDumpSettings(name, settings);
+    DebugDumpSettings(name, *immutable_.settings_);
 }
 
 PrintedDocument::~PrintedDocument() = default;
@@ -192,7 +192,7 @@ bool PrintedDocument::IsComplete() const {
   if (mutable_.converting_pdf_)
     return true;
 
-  PageNumber page(immutable_.settings_, mutable_.page_count_);
+  PageNumber page(*immutable_.settings_, mutable_.page_count_);
   if (page == PageNumber::npos())
     return false;
 
@@ -213,7 +213,7 @@ void PrintedDocument::set_page_count(int max_page) {
   base::AutoLock lock(lock_);
   DCHECK_EQ(0, mutable_.page_count_);
   mutable_.page_count_ = max_page;
-  if (immutable_.settings_.ranges().empty()) {
+  if (immutable_.settings_->ranges().empty()) {
     mutable_.expected_page_count_ = max_page;
   } else {
     // If there is a range, don't bother since expected_page_count_ is already
@@ -300,10 +300,10 @@ PrintedDocument::Mutable::Mutable() = default;
 
 PrintedDocument::Mutable::~Mutable() = default;
 
-PrintedDocument::Immutable::Immutable(const PrintSettings& settings,
+PrintedDocument::Immutable::Immutable(std::unique_ptr<PrintSettings> settings,
                                       const base::string16& name,
                                       int cookie)
-    : settings_(settings), name_(name), cookie_(cookie) {}
+    : settings_(std::move(settings)), name_(name), cookie_(cookie) {}
 
 PrintedDocument::Immutable::~Immutable() = default;
 
diff --git a/printing/printed_document.h b/printing/printed_document.h
index aaf249588e45a0..8d143269286d04 100644
--- a/printing/printed_document.h
+++ b/printing/printed_document.h
@@ -38,7 +38,7 @@ class PRINTING_EXPORT PrintedDocument
  public:
   // The cookie shall be unique and has a specific relationship with its
   // originating source and settings.
-  PrintedDocument(const PrintSettings& settings,
+  PrintedDocument(std::unique_ptr<PrintSettings> settings,
                   const base::string16& name,
                   int cookie);
 
@@ -102,7 +102,7 @@ class PRINTING_EXPORT PrintedDocument
   int expected_page_count() const;
 
   // Getters. All these items are immutable hence thread-safe.
-  const PrintSettings& settings() const { return immutable_.settings_; }
+  const PrintSettings& settings() const { return *immutable_.settings_; }
   const base::string16& name() const { return immutable_.name_; }
   int cookie() const { return immutable_.cookie_; }
 
@@ -174,13 +174,13 @@ class PRINTING_EXPORT PrintedDocument
   // any lock held. This is because it can't be changed after the object's
   // construction.
   struct Immutable {
-    Immutable(const PrintSettings& settings,
+    Immutable(std::unique_ptr<PrintSettings> settings,
               const base::string16& name,
               int cookie);
     ~Immutable();
 
     // Print settings used to generate this document. Immutable.
-    PrintSettings settings_;
+    std::unique_ptr<PrintSettings> settings_;
 
     // Document name. Immutable.
     base::string16 name_;
diff --git a/printing/printed_document_mac.cc b/printing/printed_document_mac.cc
index 1cfa1eebfc1e2b..0df77e622f2aff 100644
--- a/printing/printed_document_mac.cc
+++ b/printing/printed_document_mac.cc
@@ -27,7 +27,7 @@ bool PrintedDocument::RenderPrintedDocument(PrintingContext* context) {
   }
 
   DCHECK(metafile);
-  const PageSetup& page_setup = immutable_.settings_.page_setup_device_units();
+  const PageSetup& page_setup = immutable_.settings_->page_setup_device_units();
   gfx::Rect content_area = GetCenteredPageContentRect(
       page_setup.physical_size(), page_size, page_content_rect);
 
diff --git a/printing/printed_document_unittest.cc b/printing/printed_document_unittest.cc
index efb2aa8e44048e..9f17af10ec0ab4 100644
--- a/printing/printed_document_unittest.cc
+++ b/printing/printed_document_unittest.cc
@@ -10,12 +10,12 @@ namespace printing {
 
 TEST(PrintedDocumentTest, GetCenteredPageContentRect) {
   scoped_refptr<PrintedDocument> document;
-  PrintSettings settings;
   gfx::Rect page_content;
   const base::string16 name(base::ASCIIToUTF16("name"));
 
   // No centering.
-  document = base::MakeRefCounted<PrintedDocument>(settings, name, 1);
+  document = base::MakeRefCounted<PrintedDocument>(
+      std::make_unique<PrintSettings>(), name, 1);
   gfx::Size page_size = gfx::Size(1200, 1200);
   gfx::Rect page_content_rect = gfx::Rect(0, 0, 400, 1100);
   page_content = document->GetCenteredPageContentRect(
@@ -26,7 +26,8 @@ TEST(PrintedDocumentTest, GetCenteredPageContentRect) {
   EXPECT_EQ(1100, page_content.height());
 
   // X centered.
-  document = base::MakeRefCounted<PrintedDocument>(settings, name, 1);
+  document = base::MakeRefCounted<PrintedDocument>(
+      std::make_unique<PrintSettings>(), name, 1);
   page_size = gfx::Size(500, 1200);
   page_content = document->GetCenteredPageContentRect(
       gfx::Size(1000, 1000), page_size, page_content_rect);
@@ -36,7 +37,8 @@ TEST(PrintedDocumentTest, GetCenteredPageContentRect) {
   EXPECT_EQ(1100, page_content.height());
 
   // Y centered.
-  document = base::MakeRefCounted<PrintedDocument>(settings, name, 1);
+  document = base::MakeRefCounted<PrintedDocument>(
+      std::make_unique<PrintSettings>(), name, 1);
   page_size = gfx::Size(1200, 500);
   page_content = document->GetCenteredPageContentRect(
       gfx::Size(1000, 1000), page_size, page_content_rect);
@@ -46,7 +48,8 @@ TEST(PrintedDocumentTest, GetCenteredPageContentRect) {
   EXPECT_EQ(1100, page_content.height());
 
   // Both X and Y centered.
-  document = base::MakeRefCounted<PrintedDocument>(settings, name, 1);
+  document = base::MakeRefCounted<PrintedDocument>(
+      std::make_unique<PrintSettings>(), name, 1);
   page_size = gfx::Size(500, 500),
   page_content = document->GetCenteredPageContentRect(
       gfx::Size(1000, 1000), page_size, page_content_rect);
diff --git a/printing/printed_document_win.cc b/printing/printed_document_win.cc
index e0835204da403e..fae513ed5d1d89 100644
--- a/printing/printed_document_win.cc
+++ b/printing/printed_document_win.cc
@@ -41,7 +41,7 @@ void PrintedDocument::RenderPrintedPage(
 
   DCHECK(context);
 
-  const PageSetup& page_setup = immutable_.settings_.page_setup_device_units();
+  const PageSetup& page_setup = immutable_.settings_->page_setup_device_units();
   gfx::Rect content_area = GetCenteredPageContentRect(
       page_setup.physical_size(), page.page_size(), page.page_content_rect());
 
diff --git a/printing/printing_context.cc b/printing/printing_context.cc
index 78e3c3b2e1bea0..cd5c27c87df175 100644
--- a/printing/printing_context.cc
+++ b/printing/printing_context.cc
@@ -4,6 +4,8 @@
 
 #include "printing/printing_context.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "printing/page_setup.h"
 #include "printing/page_size_margins.h"
@@ -18,7 +20,10 @@ const float kCloudPrintMarginInch = 0.25;
 }
 
 PrintingContext::PrintingContext(Delegate* delegate)
-    : delegate_(delegate), in_print_job_(false), abort_printing_(false) {
+    : settings_(std::make_unique<PrintSettings>()),
+      delegate_(delegate),
+      in_print_job_(false),
+      abort_printing_(false) {
   DCHECK(delegate_);
 }
 
@@ -26,25 +31,36 @@ PrintingContext::~PrintingContext() = default;
 
 void PrintingContext::set_margin_type(MarginType type) {
   DCHECK(type != CUSTOM_MARGINS);
-  settings_.set_margin_type(type);
+  settings_->set_margin_type(type);
 }
 
 void PrintingContext::set_is_modifiable(bool is_modifiable) {
-  settings_.set_is_modifiable(is_modifiable);
+  settings_->set_is_modifiable(is_modifiable);
 #if defined(OS_WIN)
-  settings_.set_print_text_with_gdi(is_modifiable);
+  settings_->set_print_text_with_gdi(is_modifiable);
 #endif
 }
 
+const PrintSettings& PrintingContext::settings() const {
+  DCHECK(!in_print_job_);
+  return *settings_;
+}
+
 void PrintingContext::ResetSettings() {
   ReleaseContext();
 
-  settings_.Clear();
+  settings_->Clear();
 
   in_print_job_ = false;
   abort_printing_ = false;
 }
 
+std::unique_ptr<PrintSettings> PrintingContext::TakeAndResetSettings() {
+  std::unique_ptr<PrintSettings> result = std::move(settings_);
+  settings_ = std::make_unique<PrintSettings>();
+  return result;
+}
+
 PrintingContext::Result PrintingContext::OnError() {
   Result result = abort_printing_ ? CANCEL : FAILED;
   ResetSettings();
@@ -79,7 +95,7 @@ PrintingContext::Result PrintingContext::UpdatePrintSettings(
     base::Value job_settings) {
   ResetSettings();
 
-  if (!PrintSettingsFromJobSettings(job_settings, &settings_)) {
+  if (!PrintSettingsFromJobSettings(job_settings, settings_.get())) {
     NOTREACHED();
     return OnError();
   }
@@ -111,24 +127,25 @@ PrintingContext::Result PrintingContext::UpdatePrintSettings(
   if (!open_in_external_preview &&
       (print_to_pdf || print_to_cloud || is_cloud_dialog || print_with_privet ||
        print_with_extension)) {
-    settings_.set_dpi(kDefaultPdfDpi);
+    settings_->set_dpi(kDefaultPdfDpi);
     gfx::Size paper_size(GetPdfPaperSizeDeviceUnits());
-    if (!settings_.requested_media().size_microns.IsEmpty()) {
+    if (!settings_->requested_media().size_microns.IsEmpty()) {
       float device_microns_per_device_unit =
           static_cast<float>(kMicronsPerInch) /
-          settings_.device_units_per_inch();
-      paper_size = gfx::Size(settings_.requested_media().size_microns.width() /
-                                 device_microns_per_device_unit,
-                             settings_.requested_media().size_microns.height() /
-                                 device_microns_per_device_unit);
+          settings_->device_units_per_inch();
+      paper_size =
+          gfx::Size(settings_->requested_media().size_microns.width() /
+                        device_microns_per_device_unit,
+                    settings_->requested_media().size_microns.height() /
+                        device_microns_per_device_unit);
     }
     gfx::Rect paper_rect(0, 0, paper_size.width(), paper_size.height());
     if (print_to_cloud || print_with_privet) {
       paper_rect.Inset(
-          kCloudPrintMarginInch * settings_.device_units_per_inch(),
-          kCloudPrintMarginInch * settings_.device_units_per_inch());
+          kCloudPrintMarginInch * settings_->device_units_per_inch(),
+          kCloudPrintMarginInch * settings_->device_units_per_inch());
     }
-    settings_.SetPrinterPrintableArea(paper_size, paper_rect, true);
+    settings_->SetPrinterPrintableArea(paper_size, paper_rect, true);
     return OK;
   }
 
@@ -142,7 +159,7 @@ PrintingContext::Result PrintingContext::UpdatePrintSettings(
 PrintingContext::Result PrintingContext::UpdatePrintSettingsFromPOD(
     std::unique_ptr<PrintSettings> job_settings) {
   ResetSettings();
-  settings_ = *job_settings;
+  settings_ = std::move(job_settings);
 
   return UpdatePrinterSettings(false /* external_preview */,
                                false /* show_system_dialog */,
diff --git a/printing/printing_context.h b/printing/printing_context.h
index 9ccc1a6680bced..6a5a7c90ef5ba8 100644
--- a/printing/printing_context.h
+++ b/printing/printing_context.h
@@ -125,7 +125,9 @@ class PRINTING_EXPORT PrintingContext {
   void set_margin_type(MarginType type);
   void set_is_modifiable(bool is_modifiable);
 
-  const PrintSettings& settings() const { return settings_; }
+  const PrintSettings& settings() const;
+
+  std::unique_ptr<PrintSettings> TakeAndResetSettings();
 
   int job_id() const { return job_id_; }
 
@@ -139,7 +141,7 @@ class PRINTING_EXPORT PrintingContext {
   PrintingContext::Result OnError();
 
   // Complete print context settings.
-  PrintSettings settings_;
+  std::unique_ptr<PrintSettings> settings_;
 
   // Printing context delegate.
   Delegate* const delegate_;
diff --git a/printing/printing_context_android.cc b/printing/printing_context_android.cc
index 05f9ed64b6ccfa..6bad14cd792225 100644
--- a/printing/printing_context_android.cc
+++ b/printing/printing_context_android.cc
@@ -6,6 +6,8 @@
 
 #include <stdint.h>
 
+#include <memory>
+#include <utility>
 #include <vector>
 
 #include "base/android/jni_android.h"
@@ -126,14 +128,14 @@ void PrintingContextAndroid::AskUserForSettingsReply(
   // TODO(thestig): See if the call to set_device_name() can be removed.
   fd_ = Java_PrintingContext_getFileDescriptor(env, j_printing_context_);
   DCHECK(is_file_descriptor_valid());
-  settings_.set_device_name(base::NumberToString16(fd_));
+  settings_->set_device_name(base::NumberToString16(fd_));
 
   ScopedJavaLocalRef<jintArray> intArr =
       Java_PrintingContext_getPages(env, j_printing_context_);
   if (!intArr.is_null()) {
     PageRanges range_vector;
     GetPageRanges(env, intArr, &range_vector);
-    settings_.set_ranges(range_vector);
+    settings_->set_ranges(range_vector);
   }
 
   int dpi = Java_PrintingContext_getDpi(env, j_printing_context_);
@@ -141,7 +143,7 @@ void PrintingContextAndroid::AskUserForSettingsReply(
   int height = Java_PrintingContext_getHeight(env, j_printing_context_);
   width = ConvertUnit(width, kMilsPerInch, dpi);
   height = ConvertUnit(height, kMilsPerInch, dpi);
-  SetSizes(&settings_, dpi, width, height);
+  SetSizes(settings_.get(), dpi, width, height);
 
   std::move(callback_).Run(OK);
 }
@@ -166,9 +168,9 @@ PrintingContext::Result PrintingContextAndroid::UseDefaultSettings() {
   DCHECK(!in_print_job_);
 
   ResetSettings();
-  settings_.set_dpi(kDefaultPdfDpi);
+  settings_->set_dpi(kDefaultPdfDpi);
   gfx::Size physical_size = GetPdfPaperSizeDeviceUnits();
-  SetSizes(&settings_, kDefaultPdfDpi, physical_size.width(),
+  SetSizes(settings_.get(), kDefaultPdfDpi, physical_size.width(),
            physical_size.height());
   return OK;
 }
@@ -185,13 +187,13 @@ gfx::Size PrintingContextAndroid::GetPdfPaperSizeDeviceUnits() {
     LOG(WARNING) << "ulocdata_getPaperSize failed, using 8.5 x 11, error: "
                  << error;
     width =
-        static_cast<int>(kLetterWidthInch * settings_.device_units_per_inch());
-    height =
-        static_cast<int>(kLetterHeightInch * settings_.device_units_per_inch());
+        static_cast<int>(kLetterWidthInch * settings_->device_units_per_inch());
+    height = static_cast<int>(kLetterHeightInch *
+                              settings_->device_units_per_inch());
   } else {
     // ulocdata_getPaperSize returns the width and height in mm.
     // Convert this to pixels based on the dpi.
-    float multiplier = settings_.device_units_per_inch() / kMicronsPerMil;
+    float multiplier = settings_->device_units_per_inch() / kMicronsPerMil;
     width *= multiplier;
     height *= multiplier;
   }
diff --git a/printing/printing_context_chromeos.cc b/printing/printing_context_chromeos.cc
index ed78b7619e374b..b48cbe13e17f54 100644
--- a/printing/printing_context_chromeos.cc
+++ b/printing/printing_context_chromeos.cc
@@ -178,15 +178,15 @@ PrintingContext::Result PrintingContextChromeos::UseDefaultSettings() {
 
   ResetSettings();
 
-  std::string device_name = base::UTF16ToUTF8(settings_.device_name());
+  std::string device_name = base::UTF16ToUTF8(settings_->device_name());
   if (device_name.empty())
     return OnError();
 
   // TODO(skau): https://crbug.com/613779. See UpdatePrinterSettings for more
   // info.
-  if (settings_.dpi() == 0) {
+  if (settings_->dpi() == 0) {
     DVLOG(1) << "Using Default DPI";
-    settings_.set_dpi(kDefaultPdfDpi);
+    settings_->set_dpi(kDefaultPdfDpi);
   }
 
   // Retrieve device information and set it
@@ -202,9 +202,9 @@ PrintingContext::Result PrintingContextChromeos::UseDefaultSettings() {
   PrintSettings::RequestedMedia media;
   media.vendor_id = paper.vendor_id;
   media.size_microns = paper.size_um;
-  settings_.set_requested_media(media);
+  settings_->set_requested_media(media);
 
-  SetPrintableArea(&settings_, media, true /* flip landscape */);
+  SetPrintableArea(settings_.get(), media, true /* flip landscape */);
 
   return OK;
 }
@@ -220,13 +220,13 @@ gfx::Size PrintingContextChromeos::GetPdfPaperSizeDeviceUnits() {
     LOG(WARNING) << "ulocdata_getPaperSize failed, using 8.5 x 11, error: "
                  << error;
     width =
-        static_cast<int>(kLetterWidthInch * settings_.device_units_per_inch());
-    height =
-        static_cast<int>(kLetterHeightInch * settings_.device_units_per_inch());
+        static_cast<int>(kLetterWidthInch * settings_->device_units_per_inch());
+    height = static_cast<int>(kLetterHeightInch *
+                              settings_->device_units_per_inch());
   } else {
     // ulocdata_getPaperSize returns the width and height in mm.
     // Convert this to pixels based on the dpi.
-    float multiplier = settings_.device_units_per_inch() / kMicronsPerMil;
+    float multiplier = settings_->device_units_per_inch() / kMicronsPerMil;
     width *= multiplier;
     height *= multiplier;
   }
@@ -239,20 +239,20 @@ PrintingContext::Result PrintingContextChromeos::UpdatePrinterSettings(
     int page_count) {
   DCHECK(!show_system_dialog);
 
-  if (InitializeDevice(base::UTF16ToUTF8(settings_.device_name())) != OK)
+  if (InitializeDevice(base::UTF16ToUTF8(settings_->device_name())) != OK)
     return OnError();
 
   // TODO(skau): Convert to DCHECK when https://crbug.com/613779 is resolved
   // Print quality suffers when this is set to the resolution reported by the
   // printer but print quality is fine at this resolution. UseDefaultSettings
   // exhibits the same problem.
-  if (settings_.dpi() == 0) {
+  if (settings_->dpi() == 0) {
     DVLOG(1) << "Using Default DPI";
-    settings_.set_dpi(kDefaultPdfDpi);
+    settings_->set_dpi(kDefaultPdfDpi);
   }
 
   // compute paper size
-  PrintSettings::RequestedMedia media = settings_.requested_media();
+  PrintSettings::RequestedMedia media = settings_->requested_media();
 
   if (media.IsDefault()) {
     DCHECK(printer_);
@@ -260,13 +260,13 @@ PrintingContext::Result PrintingContextChromeos::UpdatePrinterSettings(
 
     media.vendor_id = paper.vendor_id;
     media.size_microns = paper.size_um;
-    settings_.set_requested_media(media);
+    settings_->set_requested_media(media);
   }
 
-  SetPrintableArea(&settings_, media, true);
-  cups_options_ = SettingsToCupsOptions(settings_);
-  send_user_info_ = settings_.send_user_info();
-  username_ = send_user_info_ ? settings_.username() : std::string();
+  SetPrintableArea(settings_.get(), media, true);
+  cups_options_ = SettingsToCupsOptions(*settings_);
+  send_user_info_ = settings_->send_user_info();
+  username_ = send_user_info_ ? settings_->username() : std::string();
 
   return OK;
 }
diff --git a/printing/printing_context_linux.cc b/printing/printing_context_linux.cc
index 5adcfd39b5b977..38d9e8e9527b1e 100644
--- a/printing/printing_context_linux.cc
+++ b/printing/printing_context_linux.cc
@@ -122,14 +122,19 @@ PrintingContext::Result PrintingContextLinux::UpdatePrinterSettings(
     print_dialog_->AddRefToDialog();
   }
 
-  print_dialog_->UpdateSettings(&settings_);
+  // PrintDialogGtk::UpdateSettings() calls InitWithSettings() so settings_ will
+  // remain non-null after this line.
+  print_dialog_->UpdateSettings(std::move(settings_));
+  DCHECK(settings_);
+
   return OK;
 }
 
-void PrintingContextLinux::InitWithSettings(const PrintSettings& settings) {
+void PrintingContextLinux::InitWithSettings(
+    std::unique_ptr<PrintSettings> settings) {
   DCHECK(!in_print_job_);
 
-  settings_ = settings;
+  settings_ = std::move(settings);
 }
 
 PrintingContext::Result PrintingContextLinux::NewDocument(
diff --git a/printing/printing_context_linux.h b/printing/printing_context_linux.h
index 2ceb3be4117c70..81932116fa2afb 100644
--- a/printing/printing_context_linux.h
+++ b/printing/printing_context_linux.h
@@ -5,6 +5,7 @@
 #ifndef PRINTING_PRINTING_CONTEXT_LINUX_H_
 #define PRINTING_PRINTING_CONTEXT_LINUX_H_
 
+#include <memory>
 #include <string>
 
 #include "base/macros.h"
@@ -33,7 +34,7 @@ class PRINTING_EXPORT PrintingContextLinux : public PrintingContext {
   void PrintDocument(const MetafilePlayer& metafile);
 
   // Initializes with predefined settings.
-  void InitWithSettings(const PrintSettings& settings);
+  void InitWithSettings(std::unique_ptr<PrintSettings> settings);
 
   // PrintingContext implementation.
   void AskUserForSettings(int max_pages,
diff --git a/printing/printing_context_mac.mm b/printing/printing_context_mac.mm
index dc1694d244c09a..121b01018f4431 100644
--- a/printing/printing_context_mac.mm
+++ b/printing/printing_context_mac.mm
@@ -131,7 +131,7 @@ PMPaper MatchPaper(CFArrayRef paper_list,
     NSInteger selection = [panel runModalWithPrintInfo:printInfo];
     if (selection == NSOKButton) {
       print_info_.reset([[panel printInfo] retain]);
-      settings_.set_ranges(GetPageRangesFromPrintInfo());
+      settings_->set_ranges(GetPageRangesFromPrintInfo());
       InitPrintSettingsFromPrintInfo();
       std::move(block_callback).Run(OK);
     } else {
@@ -154,7 +154,7 @@ PMPaper MatchPaper(CFArrayRef paper_list,
   // Device units are in points. Units per inch is 72.
   gfx::Size physical_size_device_units((paper_rect.right - paper_rect.left),
                                        (paper_rect.bottom - paper_rect.top));
-  DCHECK(settings_.device_units_per_inch() == kPointsPerInch);
+  DCHECK(settings_->device_units_per_inch() == kPointsPerInch);
   return physical_size_device_units;
 }
 
@@ -162,7 +162,7 @@ PMPaper MatchPaper(CFArrayRef paper_list,
   DCHECK(!in_print_job_);
 
   print_info_.reset([[NSPrintInfo sharedPrintInfo] copy]);
-  settings_.set_ranges(GetPageRangesFromPrintInfo());
+  settings_->set_ranges(GetPageRangesFromPrintInfo());
   InitPrintSettingsFromPrintInfo();
 
   return OK;
@@ -184,17 +184,17 @@ PMPaper MatchPaper(CFArrayRef paper_list,
       return OnError();
   } else {
     // Don't need this for preview.
-    if (!SetPrinter(base::UTF16ToUTF8(settings_.device_name())) ||
-        !SetCopiesInPrintSettings(settings_.copies()) ||
-        !SetCollateInPrintSettings(settings_.collate()) ||
-        !SetDuplexModeInPrintSettings(settings_.duplex_mode()) ||
-        !SetOutputColor(settings_.color())) {
+    if (!SetPrinter(base::UTF16ToUTF8(settings_->device_name())) ||
+        !SetCopiesInPrintSettings(settings_->copies()) ||
+        !SetCollateInPrintSettings(settings_->collate()) ||
+        !SetDuplexModeInPrintSettings(settings_->duplex_mode()) ||
+        !SetOutputColor(settings_->color())) {
       return OnError();
     }
   }
 
   if (!UpdatePageFormatWithPaperInfo() ||
-      !SetOrientationIsLandscape(settings_.landscape())) {
+      !SetOrientationIsLandscape(settings_->landscape())) {
     return OnError();
   }
 
@@ -221,7 +221,7 @@ PMPaper MatchPaper(CFArrayRef paper_list,
   PMPrinter printer;
   PMSessionGetCurrentPrinter(print_session, &printer);
   PrintSettingsInitializerMac::InitPrintSettings(printer, page_format,
-                                                 &settings_);
+                                                 settings_.get());
 }
 
 bool PrintingContextMac::SetPrinter(const std::string& device_name) {
@@ -272,7 +272,7 @@ PMPaper MatchPaper(CFArrayRef paper_list,
   base::ScopedCFTypeRef<CFStringRef> paper_name;
   PMPaperMargins margins = {0};
 
-  const PrintSettings::RequestedMedia& media = settings_.requested_media();
+  const PrintSettings::RequestedMedia& media = settings_->requested_media();
   if (media.IsDefault()) {
     PMPaper default_paper;
     if (PMGetPageFormatPaper(default_page_format, &default_paper) != noErr ||
diff --git a/printing/printing_context_no_system_dialog.cc b/printing/printing_context_no_system_dialog.cc
index 65d9bd24a5133c..106314b1399c51 100644
--- a/printing/printing_context_no_system_dialog.cc
+++ b/printing/printing_context_no_system_dialog.cc
@@ -8,6 +8,7 @@
 #include <unicode/ulocdata.h>
 
 #include <memory>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/values.h"
@@ -44,12 +45,12 @@ PrintingContext::Result PrintingContextNoSystemDialog::UseDefaultSettings() {
   DCHECK(!in_print_job_);
 
   ResetSettings();
-  settings_.set_dpi(kDefaultPdfDpi);
+  settings_->set_dpi(kDefaultPdfDpi);
   gfx::Size physical_size = GetPdfPaperSizeDeviceUnits();
   // Assume full page is printable for now.
   gfx::Rect printable_area(0, 0, physical_size.width(), physical_size.height());
-  DCHECK_EQ(settings_.device_units_per_inch(), kDefaultPdfDpi);
-  settings_.SetPrinterPrintableArea(physical_size, printable_area, true);
+  DCHECK_EQ(settings_->device_units_per_inch(), kDefaultPdfDpi);
+  settings_->SetPrinterPrintableArea(physical_size, printable_area, true);
   return OK;
 }
 
@@ -64,13 +65,13 @@ gfx::Size PrintingContextNoSystemDialog::GetPdfPaperSizeDeviceUnits() {
     LOG(WARNING) << "ulocdata_getPaperSize failed, using 8.5 x 11, error: "
                  << error;
     width =
-        static_cast<int>(kLetterWidthInch * settings_.device_units_per_inch());
-    height =
-        static_cast<int>(kLetterHeightInch * settings_.device_units_per_inch());
+        static_cast<int>(kLetterWidthInch * settings_->device_units_per_inch());
+    height = static_cast<int>(kLetterHeightInch *
+                              settings_->device_units_per_inch());
   } else {
     // ulocdata_getPaperSize returns the width and height in mm.
     // Convert this to pixels based on the dpi.
-    float multiplier = settings_.device_units_per_inch() / kMicronsPerMil;
+    float multiplier = settings_->device_units_per_inch() / kMicronsPerMil;
     width *= multiplier;
     height *= multiplier;
   }
@@ -83,7 +84,7 @@ PrintingContext::Result PrintingContextNoSystemDialog::UpdatePrinterSettings(
     int page_count) {
   DCHECK(!show_system_dialog);
 
-  if (settings_.dpi() == 0)
+  if (settings_->dpi() == 0)
     UseDefaultSettings();
 
   return OK;
diff --git a/printing/printing_context_system_dialog_win.cc b/printing/printing_context_system_dialog_win.cc
index 1c2d08a79772fb..a53e4045bdc8a4 100644
--- a/printing/printing_context_system_dialog_win.cc
+++ b/printing/printing_context_system_dialog_win.cc
@@ -132,11 +132,11 @@ bool PrintingContextSystemDialogWin::InitializeSettingsWithRanges(
     }
   }
 
-  settings_.set_ranges(ranges_vector);
-  settings_.set_device_name(new_device_name);
-  settings_.set_selection_only(selection_only);
+  settings_->set_ranges(ranges_vector);
+  settings_->set_device_name(new_device_name);
+  settings_->set_selection_only(selection_only);
   PrintSettingsInitializerWin::InitPrintSettings(context(), dev_mode,
-                                                 &settings_);
+                                                 settings_.get());
 
   return true;
 }
@@ -146,11 +146,11 @@ PrintingContext::Result PrintingContextSystemDialogWin::ParseDialogResultEx(
   // If the user clicked OK or Apply then Cancel, but not only Cancel.
   if (dialog_options.dwResultAction != PD_RESULT_CANCEL) {
     // Start fresh, but preserve is_modifiable and GDI print setting.
-    bool is_modifiable = settings_.is_modifiable();
-    bool print_text_with_gdi = settings_.print_text_with_gdi();
+    bool is_modifiable = settings_->is_modifiable();
+    bool print_text_with_gdi = settings_->print_text_with_gdi();
     ResetSettings();
-    settings_.set_is_modifiable(is_modifiable);
-    settings_.set_print_text_with_gdi(print_text_with_gdi);
+    settings_->set_is_modifiable(is_modifiable);
+    settings_->set_print_text_with_gdi(print_text_with_gdi);
 
     DEVMODE* dev_mode = NULL;
     if (dialog_options.hDevMode) {
diff --git a/printing/printing_context_win.cc b/printing/printing_context_win.cc
index 7f323ed03bc3a0..7115067c21c5e4 100644
--- a/printing/printing_context_win.cc
+++ b/printing/printing_context_win.cc
@@ -8,6 +8,7 @@
 #include <winspool.h>
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ -140,8 +141,8 @@ gfx::Size PrintingContextWin::GetPdfPaperSizeDeviceUnits() {
         break;
     }
   }
-  return gfx::Size(paper_size.width() * settings_.device_units_per_inch(),
-                   paper_size.height() * settings_.device_units_per_inch());
+  return gfx::Size(paper_size.width() * settings_->device_units_per_inch(),
+                   paper_size.height() * settings_->device_units_per_inch());
 }
 
 PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
@@ -152,27 +153,27 @@ PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
   DCHECK(!external_preview) << "Not implemented";
 
   ScopedPrinterHandle printer;
-  if (!printer.OpenPrinterWithName(settings_.device_name().c_str()))
+  if (!printer.OpenPrinterWithName(settings_->device_name().c_str()))
     return OnError();
 
   // Make printer changes local to Chrome.
   // See MSDN documentation regarding DocumentProperties.
   std::unique_ptr<DEVMODE, base::FreeDeleter> scoped_dev_mode =
-      CreateDevModeWithColor(printer.Get(), settings_.device_name(),
-                             settings_.color() != GRAY);
+      CreateDevModeWithColor(printer.Get(), settings_->device_name(),
+                             settings_->color() != GRAY);
   if (!scoped_dev_mode)
     return OnError();
 
   {
     DEVMODE* dev_mode = scoped_dev_mode.get();
-    dev_mode->dmCopies = std::max(settings_.copies(), 1);
+    dev_mode->dmCopies = std::max(settings_->copies(), 1);
     if (dev_mode->dmCopies > 1) {  // do not change unless multiple copies
       dev_mode->dmFields |= DM_COPIES;
       dev_mode->dmCollate =
-          settings_.collate() ? DMCOLLATE_TRUE : DMCOLLATE_FALSE;
+          settings_->collate() ? DMCOLLATE_TRUE : DMCOLLATE_FALSE;
     }
 
-    switch (settings_.duplex_mode()) {
+    switch (settings_->duplex_mode()) {
       case LONG_EDGE:
         dev_mode->dmFields |= DM_DUPLEX;
         dev_mode->dmDuplex = DMDUP_VERTICAL;
@@ -191,19 +192,19 @@ PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
 
     dev_mode->dmFields |= DM_ORIENTATION;
     dev_mode->dmOrientation =
-        settings_.landscape() ? DMORIENT_LANDSCAPE : DMORIENT_PORTRAIT;
+        settings_->landscape() ? DMORIENT_LANDSCAPE : DMORIENT_PORTRAIT;
 
-    if (settings_.dpi_horizontal() > 0) {
-      dev_mode->dmPrintQuality = settings_.dpi_horizontal();
+    if (settings_->dpi_horizontal() > 0) {
+      dev_mode->dmPrintQuality = settings_->dpi_horizontal();
       dev_mode->dmFields |= DM_PRINTQUALITY;
     }
-    if (settings_.dpi_vertical() > 0) {
-      dev_mode->dmYResolution = settings_.dpi_vertical();
+    if (settings_->dpi_vertical() > 0) {
+      dev_mode->dmYResolution = settings_->dpi_vertical();
       dev_mode->dmFields |= DM_YRESOLUTION;
     }
 
     const PrintSettings::RequestedMedia& requested_media =
-        settings_.requested_media();
+        settings_->requested_media();
     unsigned id = 0;
     // If the paper size is a custom user size, setting by ID may not work.
     if (base::StringToUint(requested_media.vendor_id, &id) && id &&
@@ -227,24 +228,24 @@ PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
   }
   // Set printer then refresh printer settings.
   scoped_dev_mode = CreateDevMode(printer.Get(), scoped_dev_mode.get());
-  return InitializeSettings(settings_.device_name(), scoped_dev_mode.get());
+  return InitializeSettings(settings_->device_name(), scoped_dev_mode.get());
 }
 
 PrintingContext::Result PrintingContextWin::InitWithSettingsForTest(
-    const PrintSettings& settings) {
+    std::unique_ptr<PrintSettings> settings) {
   DCHECK(!in_print_job_);
 
-  settings_ = settings;
+  settings_ = std::move(settings);
 
   // TODO(maruel): settings_.ToDEVMODE()
   ScopedPrinterHandle printer;
-  if (!printer.OpenPrinterWithName(settings_.device_name().c_str()))
+  if (!printer.OpenPrinterWithName(settings_->device_name().c_str()))
     return FAILED;
 
   std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
       CreateDevMode(printer.Get(), nullptr);
 
-  return InitializeSettings(settings_.device_name(), dev_mode.get());
+  return InitializeSettings(settings_->device_name(), dev_mode.get());
 }
 
 PrintingContext::Result PrintingContextWin::NewDocument(
@@ -366,9 +367,9 @@ PrintingContext::Result PrintingContextWin::InitializeSettings(
   skia::InitializeDC(context_);
 
   DCHECK(!in_print_job_);
-  settings_.set_device_name(device_name);
+  settings_->set_device_name(device_name);
   PrintSettingsInitializerWin::InitPrintSettings(context_, *dev_mode,
-                                                 &settings_);
+                                                 settings_.get());
 
   return OK;
 }
diff --git a/printing/printing_context_win.h b/printing/printing_context_win.h
index bc427a0bc71327..672307c7164d6e 100644
--- a/printing/printing_context_win.h
+++ b/printing/printing_context_win.h
@@ -22,7 +22,7 @@ class PRINTING_EXPORT PrintingContextWin : public PrintingContext {
   ~PrintingContextWin() override;
 
   // Initializes with predefined settings.
-  Result InitWithSettingsForTest(const PrintSettings& settings);
+  Result InitWithSettingsForTest(std::unique_ptr<PrintSettings> settings);
 
   // PrintingContext implementation.
   void AskUserForSettings(int max_pages,
diff --git a/printing/printing_context_win_unittest.cc b/printing/printing_context_win_unittest.cc
index 59aabfc2a19e2b..2c6bfa51675337 100644
--- a/printing/printing_context_win_unittest.cc
+++ b/printing/printing_context_win_unittest.cc
@@ -7,6 +7,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/win/scoped_handle.h"
@@ -175,11 +177,12 @@ TEST_F(PrintingContextTest, Base) {
   if (IsTestCaseDisabled())
     return;
 
-  PrintSettings settings;
-  settings.set_device_name(GetDefaultPrinter());
+  auto settings = std::make_unique<PrintSettings>();
+  settings->set_device_name(GetDefaultPrinter());
   // Initialize it.
   PrintingContextWin context(this);
-  EXPECT_EQ(PrintingContext::OK, context.InitWithSettingsForTest(settings));
+  EXPECT_EQ(PrintingContext::OK,
+            context.InitWithSettingsForTest(std::move(settings)));
 
   // The print may lie to use and may not support world transformation.
   // Verify right now.