printing/printed_document.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "printing/printed_document.h"
   6
   7 #include <algorithm>
   8 #include <set>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/file_util.h"
  14 #include "base/files/file_path.h"
  15 #include "base/i18n/file_util_icu.h"
  16 #include "base/i18n/time_formatting.h"
  17 #include "base/json/json_writer.h"
  18 #include "base/lazy_instance.h"
  19 #include "base/memory/ref_counted_memory.h"
  20 #include "base/message_loop/message_loop.h"
  21 #include "base/numerics/safe_conversions.h"
  22 #include "base/strings/string_util.h"
  23 #include "base/strings/stringprintf.h"
  24 #include "base/strings/utf_string_conversions.h"
  25 #include "base/time/time.h"
  26 #include "base/values.h"
  27 #include "printing/page_number.h"
  28 #include "printing/print_settings_conversion.h"
  29 #include "printing/printed_page.h"
  30 #include "printing/printed_pages_source.h"
  31 #include "printing/units.h"
  32 #include "skia/ext/platform_device.h"
  33 #include "ui/gfx/font.h"
  34 #include "ui/gfx/text_elider.h"
  35
  36 namespace printing {
  37
  38 namespace {
  39
  40 base::LazyInstance<base::FilePath> g_debug_dump_info =
  41     LAZY_INSTANCE_INITIALIZER;
  42
  43 void DebugDumpPageTask(const base::string16& doc_name,
  44                        const PrintedPage* page) {
  45   if (g_debug_dump_info.Get().empty())
  46     return;
  47
  48   base::string16 filename = doc_name;
  49   filename +=
  50       base::ASCIIToUTF16(base::StringPrintf("_%04d", page->page_number()));
  51 #if defined(OS_WIN)
  52   page->metafile()->SaveTo(PrintedDocument::CreateDebugDumpPath(
  53       filename, FILE_PATH_LITERAL(".emf")));
  54 #else   // OS_WIN
  55   page->metafile()->SaveTo(PrintedDocument::CreateDebugDumpPath(
  56       filename, FILE_PATH_LITERAL(".pdf")));
  57 #endif  // OS_WIN
  58 }
  59
  60 void DebugDumpDataTask(const base::string16& doc_name,
  61                        const base::FilePath::StringType& extension,
  62                        const base::RefCountedMemory* data) {
  63   base::FilePath path =
  64       PrintedDocument::CreateDebugDumpPath(doc_name, extension);
  65   if (path.empty())
  66     return;
  67   base::WriteFile(path,
  68                   reinterpret_cast<const char*>(data->front()),
  69                   base::checked_cast<int>(data->size()));
  70 }
  71
  72 void DebugDumpSettings(const base::string16& doc_name,
  73                        const PrintSettings& settings,
  74                        base::TaskRunner* blocking_runner) {
  75   base::DictionaryValue job_settings;
  76   PrintSettingsToJobSettingsDebug(settings, &job_settings);
  77   std::string settings_str;
  78   base::JSONWriter::WriteWithOptions(
  79       &job_settings, base::JSONWriter::OPTIONS_PRETTY_PRINT, &settings_str);
  80   scoped_refptr<base::RefCountedMemory> data =
  81       base::RefCountedString::TakeString(&settings_str);
  82   blocking_runner->PostTask(
  83       FROM_HERE,
  84       base::Bind(
  85           &DebugDumpDataTask, doc_name, FILE_PATH_LITERAL(".json"), data));
  86 }
  87
  88 }  // namespace
  89
  90 PrintedDocument::PrintedDocument(const PrintSettings& settings,
  91                                  PrintedPagesSource* source,
  92                                  int cookie,
  93                                  base::TaskRunner* blocking_runner)
  94     : mutable_(source), immutable_(settings, source, cookie, blocking_runner) {
  95   // Records the expected page count if a range is setup.
  96   if (!settings.ranges().empty()) {
  97     // If there is a range, set the number of page
  98     for (unsigned i = 0; i < settings.ranges().size(); ++i) {
  99       const PageRange& range = settings.ranges()[i];
 100       mutable_.expected_page_count_ += range.to - range.from + 1;
 101     }
 102   }
 103
 104   if (!g_debug_dump_info.Get().empty())
 105     DebugDumpSettings(name(), settings, blocking_runner);
 106 }
 107
 108 PrintedDocument::~PrintedDocument() {
 109 }
 110
 111 void PrintedDocument::SetPage(int page_number,
 112                               Metafile* metafile,
 113 #if defined(OS_WIN)
 114                               double shrink,
 115 #endif  // OS_WIN
 116                               const gfx::Size& paper_size,
 117                               const gfx::Rect& page_rect) {
 118   // Notice the page_number + 1, the reason is that this is the value that will
 119   // be shown. Users dislike 0-based counting.
 120   scoped_refptr<PrintedPage> page(
 121       new PrintedPage(page_number + 1, metafile, paper_size, page_rect));
 122 #if defined(OS_WIN)
 123   page->set_shrink_factor(shrink);
 124 #endif  // OS_WIN
 125   {
 126     base::AutoLock lock(lock_);
 127     mutable_.pages_[page_number] = page;
 128
 129 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 130     if (page_number < mutable_.first_page)
 131       mutable_.first_page = page_number;
 132 #endif
 133   }
 134
 135   if (!g_debug_dump_info.Get().empty()) {
 136     immutable_.blocking_runner_->PostTask(
 137         FROM_HERE, base::Bind(&DebugDumpPageTask, name(), page));
 138   }
 139 }
 140
 141 scoped_refptr<PrintedPage> PrintedDocument::GetPage(int page_number) {
 142   scoped_refptr<PrintedPage> page;
 143   {
 144     base::AutoLock lock(lock_);
 145     PrintedPages::const_iterator itr = mutable_.pages_.find(page_number);
 146     if (itr != mutable_.pages_.end())
 147       page = itr->second;
 148   }
 149   return page;
 150 }
 151
 152 bool PrintedDocument::IsComplete() const {
 153   base::AutoLock lock(lock_);
 154   if (!mutable_.page_count_)
 155     return false;
 156   PageNumber page(immutable_.settings_, mutable_.page_count_);
 157   if (page == PageNumber::npos())
 158     return false;
 159
 160   for (; page != PageNumber::npos(); ++page) {
 161 #if defined(OS_WIN) || defined(OS_MACOSX)
 162     const bool metafile_must_be_valid = true;
 163 #elif defined(OS_POSIX)
 164     const bool metafile_must_be_valid = (page.ToInt() == mutable_.first_page);
 165 #endif
 166     PrintedPages::const_iterator itr = mutable_.pages_.find(page.ToInt());
 167     if (itr == mutable_.pages_.end() || !itr->second.get())
 168       return false;
 169     if (metafile_must_be_valid && !itr->second->metafile())
 170       return false;
 171   }
 172   return true;
 173 }
 174
 175 void PrintedDocument::DisconnectSource() {
 176   base::AutoLock lock(lock_);
 177   mutable_.source_ = NULL;
 178 }
 179
 180 uint32 PrintedDocument::MemoryUsage() const {
 181   std::vector< scoped_refptr<PrintedPage> > pages_copy;
 182   {
 183     base::AutoLock lock(lock_);
 184     pages_copy.reserve(mutable_.pages_.size());
 185     PrintedPages::const_iterator end = mutable_.pages_.end();
 186     for (PrintedPages::const_iterator itr = mutable_.pages_.begin();
 187          itr != end; ++itr) {
 188       if (itr->second.get()) {
 189         pages_copy.push_back(itr->second);
 190       }
 191     }
 192   }
 193   uint32 total = 0;
 194   for (size_t i = 0; i < pages_copy.size(); ++i) {
 195     total += pages_copy[i]->metafile()->GetDataSize();
 196   }
 197   return total;
 198 }
 199
 200 void PrintedDocument::set_page_count(int max_page) {
 201   base::AutoLock lock(lock_);
 202   DCHECK_EQ(0, mutable_.page_count_);
 203   mutable_.page_count_ = max_page;
 204   if (immutable_.settings_.ranges().empty()) {
 205     mutable_.expected_page_count_ = max_page;
 206   } else {
 207     // If there is a range, don't bother since expected_page_count_ is already
 208     // initialized.
 209     DCHECK_NE(mutable_.expected_page_count_, 0);
 210   }
 211 }
 212
 213 int PrintedDocument::page_count() const {
 214   base::AutoLock lock(lock_);
 215   return mutable_.page_count_;
 216 }
 217
 218 int PrintedDocument::expected_page_count() const {
 219   base::AutoLock lock(lock_);
 220   return mutable_.expected_page_count_;
 221 }
 222
 223 void PrintedDocument::set_debug_dump_path(
 224     const base::FilePath& debug_dump_path) {
 225   g_debug_dump_info.Get() = debug_dump_path;
 226 }
 227
 228 base::FilePath PrintedDocument::CreateDebugDumpPath(
 229     const base::string16& document_name,
 230     const base::FilePath::StringType& extension) {
 231   if (g_debug_dump_info.Get().empty())
 232     return base::FilePath();
 233   // Create a filename.
 234   base::string16 filename;
 235   base::Time now(base::Time::Now());
 236   filename = base::TimeFormatShortDateAndTime(now);
 237   filename += base::ASCIIToUTF16("_");
 238   filename += document_name;
 239   base::FilePath::StringType system_filename;
 240 #if defined(OS_WIN)
 241   system_filename = filename;
 242 #else   // OS_WIN
 243   system_filename = base::UTF16ToUTF8(filename);
 244 #endif  // OS_WIN
 245   file_util::ReplaceIllegalCharactersInPath(&system_filename, '_');
 246   return g_debug_dump_info.Get().Append(system_filename).AddExtension(
 247       extension);
 248 }
 249
 250 void PrintedDocument::DebugDumpData(
 251     const base::RefCountedMemory* data,
 252     const base::FilePath::StringType& extension) {
 253   if (g_debug_dump_info.Get().empty())
 254     return;
 255   immutable_.blocking_runner_->PostTask(
 256       FROM_HERE, base::Bind(&DebugDumpDataTask, name(), extension, data));
 257 }
 258
 259 PrintedDocument::Mutable::Mutable(PrintedPagesSource* source)
 260     : source_(source),
 261       expected_page_count_(0),
 262       page_count_(0) {
 263 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 264   first_page = INT_MAX;
 265 #endif
 266 }
 267
 268 PrintedDocument::Mutable::~Mutable() {
 269 }
 270
 271 PrintedDocument::Immutable::Immutable(const PrintSettings& settings,
 272                                       PrintedPagesSource* source,
 273                                       int cookie,
 274                                       base::TaskRunner* blocking_runner)
 275     : settings_(settings),
 276       name_(source->RenderSourceName()),
 277       cookie_(cookie),
 278       blocking_runner_(blocking_runner) {
 279 }
 280
 281 PrintedDocument::Immutable::~Immutable() {
 282 }
 283
 284 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
 285 // This function is not used on aura linux/chromeos or android.
 286 void PrintedDocument::RenderPrintedPage(const PrintedPage& page,
 287                                         PrintingContext* context) const {
 288 }
 289 #endif
 290
 291 }  // namespace printing