Move Emf class to the printing library. Also creates a platform agnostic Nat...

chrome/browser/printing/printed_document.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/printing/printed_document.h"
 
 #include <set>
 
 #include "app/gfx/font.h"
 #include "app/gfx/text_elider.h"
 #include "app/win_util.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "chrome/browser/printing/page_number.h"
 #include "chrome/browser/printing/page_overlays.h"
 #include "chrome/browser/printing/printed_pages_source.h"
 #include "chrome/browser/printing/printed_page.h"
-#include "chrome/common/gfx/emf.h"
 #include "printing/units.h"
 #include "skia/ext/platform_device.h"
 
 using base::Time;
 
 namespace {
 
 struct PrintDebugDumpPath {
   PrintDebugDumpPath()
     : enabled(false) {
@@ skipping 21 matching lines @@
     for (unsigned i = 0; i < settings.ranges.size(); ++i) {
       const PageRange& range = settings.ranges[i];
       mutable_.expected_page_count_ += range.to - range.from + 1;
     }
   }
 }
 
 PrintedDocument::~PrintedDocument() {
 }
 
-void PrintedDocument::SetPage(int page_number, gfx::Emf* emf, double shrink) {
+void PrintedDocument::SetPage(int page_number,
+                              NativeMetafile* metafile,
+                              double shrink) {
   // Notice the page_number + 1, the reason is that this is the value that will
   // be shown. Users dislike 0-based counting.
   scoped_refptr<PrintedPage> page(
       new PrintedPage(page_number + 1,
-          emf, immutable_.settings_.page_setup_pixels().physical_size()));
+          metafile, immutable_.settings_.page_setup_pixels().physical_size()));
   {
     AutoLock lock(lock_);
     mutable_.pages_[page_number] = page;
     if (mutable_.shrink_factor == 0) {
       mutable_.shrink_factor = shrink;
     } else {
       DCHECK_EQ(mutable_.shrink_factor, shrink);
     }
   }
   DebugDump(*page);
@@ skipping 37 matching lines @@
     XFORM xform = { 0 };
     xform.eDx = static_cast<float>(
         immutable_.settings_.page_setup_pixels().content_area().x());
     xform.eDy = static_cast<float>(
         immutable_.settings_.page_setup_pixels().content_area().y());
     xform.eM11 = static_cast<float>(1. / mutable_.shrink_factor);
     xform.eM22 = static_cast<float>(1. / mutable_.shrink_factor);
     BOOL res = ModifyWorldTransform(context, &xform, MWT_LEFTMULTIPLY);
     DCHECK_NE(res, 0);
 
-    if (!page.emf()->SafePlayback(context)) {
+    if (!page.native_metafile()->SafePlayback(context)) {
       NOTREACHED();
     }
 
     res = RestoreDC(context, saved_state);
     DCHECK_NE(res, 0);
   }
 
   // Print the header and footer.
   int base_font_size = gfx::Font().height();
   int new_font_size = ConvertUnit(10,
@@ skipping 32 matching lines @@
 bool PrintedDocument::IsComplete() const {
   AutoLock lock(lock_);
   if (!mutable_.page_count_)
     return false;
   PageNumber page(immutable_.settings_, mutable_.page_count_);
   if (page == PageNumber::npos())
     return false;
   for (; page != PageNumber::npos(); ++page) {
     PrintedPages::const_iterator itr = mutable_.pages_.find(page.ToInt());
     if (itr == mutable_.pages_.end() || !itr->second.get() ||
-        !itr->second->emf())
+        !itr->second->native_metafile())
       return false;
   }
   return true;
 }
 
 void PrintedDocument::DisconnectSource() {
   AutoLock lock(lock_);
   mutable_.source_ = NULL;
 }
 
 size_t PrintedDocument::MemoryUsage() const {
   std::vector<scoped_refptr<PrintedPage>> pages_copy;
   {
     AutoLock lock(lock_);
     pages_copy.reserve(mutable_.pages_.size());
     PrintedPages::const_iterator end = mutable_.pages_.end();
     for (PrintedPages::const_iterator itr = mutable_.pages_.begin();
          itr != end; ++itr) {
       if (itr->second.get()) {
         pages_copy.push_back(itr->second);
       }
     }
   }
   size_t total = 0;
   for (size_t i = 0; i < pages_copy.size(); ++i) {
-    total += pages_copy[i]->emf()->GetDataSize();
+    total += pages_copy[i]->native_metafile()->GetDataSize();
   }
   return total;
 }
 
 void PrintedDocument::set_page_count(int max_page) {
   AutoLock lock(lock_);
   DCHECK_EQ(0, mutable_.page_count_);
   mutable_.page_count_ = max_page;
   if (immutable_.settings_.ranges.empty()) {
     mutable_.expected_page_count_ = max_page;
@@ skipping 98 matching lines @@
   filename += L"_";
   filename += time();
   filename += L"_";
   filename += name();
   filename += L"_";
   filename += StringPrintf(L"%02d", page.page_number());
   filename += L"_.emf";
   file_util::ReplaceIllegalCharacters(&filename, '_');
   std::wstring path(g_debug_dump_info->debug_dump_path);
   file_util::AppendToPath(&path, filename);
-  page.emf()->SaveTo(path);
+  page.native_metafile()->SaveTo(path);
 }
 
 void PrintedDocument::set_debug_dump_path(const std::wstring& debug_dump_path) {
   g_debug_dump_info->enabled = !debug_dump_path.empty();
   g_debug_dump_info->debug_dump_path = debug_dump_path;
 }
 
 const std::wstring& PrintedDocument::debug_dump_path() {
   return g_debug_dump_info->debug_dump_path;
 }
@@ skipping 21 matching lines @@
   date_ = win_util::FormatSystemDate(systemtime, std::wstring());
   time_ = win_util::FormatSystemTime(systemtime, std::wstring());
 #else
   Time now = Time::Now();
   date_ = TimeFormat::ShortDateNumeric(now);
   time_ = TimeFormat::TimeOfDay(now);
 #endif  // WIN32
 }
 
 }  // namespace printing