Fix printing project on linux.

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 "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 "base/time_format.h"
 #include "printing/page_number.h"
 #include "printing/page_overlays.h"
 #include "printing/printed_pages_source.h"
 #include "printing/printed_page.h"
 #include "printing/units.h"
 #include "skia/ext/platform_device.h"
 
+#if defined(OS_WIN)
+#include "app/win_util.h"
+#endif
+
 using base::Time;
 
 namespace {
 
 struct PrintDebugDumpPath {
   PrintDebugDumpPath()
     : enabled(false) {
   }
 
   bool enabled;
   std::wstring debug_dump_path;
 };
 
 Singleton<PrintDebugDumpPath> g_debug_dump_info;
 
+#if defined(OS_WIN)
 void SimpleModifyWorldTransform(HDC context,
                                 int offset_x,
                                 int offset_y,
                                 double shrink_factor) {
   XFORM xform = { 0 };
   xform.eDx = static_cast<float>(offset_x);
   xform.eDy = static_cast<float>(offset_y);
   xform.eM11 = xform.eM22 = static_cast<float>(1. / shrink_factor);
   BOOL res = ModifyWorldTransform(context, &xform, MWT_LEFTMULTIPLY);
   DCHECK_NE(res, 0);
 }
 
 void DrawRect(HDC context, gfx::Rect rect) {
   Rectangle(context, rect.x(), rect.y(), rect.right(), rect.bottom());
 }
+#endif  // OS_WIN
 
 }  // namespace
 
 namespace printing {
 
 PrintedDocument::PrintedDocument(const PrintSettings& settings,
                                  PrintedPagesSource* source,
                                  int cookie)
     : mutable_(source),
       immutable_(settings, source, cookie) {
@@ skipping 47 matching lines @@
 void PrintedDocument::RenderPrintedPage(const PrintedPage& page,
                                         HDC context) const {
 #ifndef NDEBUG
   {
     // Make sure the page is from our list.
     AutoLock lock(lock_);
     DCHECK(&page == mutable_.pages_.find(page.page_number() - 1)->second.get());
   }
 #endif
 
+#if defined(OS_WIN)
   const printing::PageSetup& page_setup(
       immutable_.settings_.page_setup_pixels());
 
   // Save the state to make sure the context this function call does not modify
   // the device context.
   int saved_state = SaveDC(context);
   DCHECK_NE(saved_state, 0);
   skia::PlatformDevice::InitializeDC(context);
   {
     // Save the state (again) to apply the necessary world transformation.
@@ skipping 68 matching lines @@
   PrintHeaderFooter(context, page, PageOverlays::RIGHT, PageOverlays::TOP,
                     font);
   PrintHeaderFooter(context, page, PageOverlays::LEFT, PageOverlays::BOTTOM,
                     font);
   PrintHeaderFooter(context, page, PageOverlays::CENTER, PageOverlays::BOTTOM,
                     font);
   PrintHeaderFooter(context, page, PageOverlays::RIGHT, PageOverlays::BOTTOM,
                     font);
   int res = RestoreDC(context, saved_state);
   DCHECK_NE(res, 0);
+#else  // OS_WIN
+  NOTIMPLEMENTED();
+#endif  // OS_WIN
 }
 
 bool PrintedDocument::RenderPrintedPageNumber(int page_number, HDC context) {
   scoped_refptr<PrintedPage> page;
   if (!GetPage(page_number, &page))
     return false;
   RenderPrintedPage(*page.get(), context);
   return true;
 }
 
@@ skipping 12 matching lines @@
   }
   return true;
 }
 
 void PrintedDocument::DisconnectSource() {
   AutoLock lock(lock_);
   mutable_.source_ = NULL;
 }
 
 size_t PrintedDocument::MemoryUsage() const {
-  std::vector<scoped_refptr<PrintedPage>> pages_copy;
+  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);
       }
     }
@@ skipping 80 matching lines @@
   }
 
   if (string_size.width() > bounding.width()) {
     if (line == PageOverlays::kUrl) {
       output = gfx::ElideUrl(url(), font, bounding.width(), std::wstring());
     } else {
       output = gfx::ElideText(output, font, bounding.width());
     }
   }
 
+#if defined(OS_WIN)
   // Save the state (again) for the clipping region.
   int saved_state = SaveDC(context);
   DCHECK_NE(saved_state, 0);
 
   int result = IntersectClipRect(context, bounding.x(), bounding.y(),
                                  bounding.right() + 1, bounding.bottom() + 1);
   DCHECK(result == SIMPLEREGION || result == COMPLEXREGION);
   TextOut(context,
           bounding.x(), bounding.y(),
           output.c_str(),
           static_cast<int>(output.size()));
   int res = RestoreDC(context, saved_state);
   DCHECK_NE(res, 0);
+#else  // OS_WIN
+  NOTIMPLEMENTED();
+#endif  // OS_WIN
 }
 
 void PrintedDocument::DebugDump(const PrintedPage& page) {
   if (!g_debug_dump_info->enabled)
     return;
 
   std::wstring filename;
   filename += date();
   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);
+#if defined(OS_WIN)
   page.native_metafile()->SaveTo(path);
+#else  // OS_WIN
+  NOTIMPLEMENTED();
+#endif  // OS_WIN
 }
 
 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;
 }
 
 PrintedDocument::Mutable::Mutable(PrintedPagesSource* source)
     : source_(source),
       expected_page_count_(0),
       page_count_(0),
       shrink_factor(0) {
 }
 
 PrintedDocument::Immutable::Immutable(const PrintSettings& settings,
                                       PrintedPagesSource* source,
                                       int cookie)
     : settings_(settings),
       source_message_loop_(MessageLoop::current()),
       name_(source->RenderSourceName()),
       url_(source->RenderSourceUrl()),
       cookie_(cookie) {
   // Setup the document's date.
-#ifdef WIN32
+#if defined(OS_WIN)
   // On Windows, use the native time formatting for printing.
   SYSTEMTIME systemtime;
   GetLocalTime(&systemtime);
   date_ = win_util::FormatSystemDate(systemtime, std::wstring());
   time_ = win_util::FormatSystemTime(systemtime, std::wstring());
-#else
+#else  // OS_WIN
   Time now = Time::Now();
-  date_ = TimeFormat::ShortDateNumeric(now);
-  time_ = TimeFormat::TimeOfDay(now);
-#endif  // WIN32
+  date_ = base::TimeFormatShortDateNumeric(now);
+  time_ = base::TimeFormatTimeOfDay(now);
+#endif  // OS_WIN
 }
 
 }  // namespace printing