StartPage/EndPage from spooling code.

printing/emf_win.cc

 // Copyright (c) 2012 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/emf_win.h"
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/scoped_select_object.h"
 #include "skia/ext/vector_platform_device_emf_win.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/gdi_util.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 namespace {
 
-const int kCustomGdiCommentSignature = 0xdeadbabe;
-struct PageBreakRecord {
-  int signature;
-  enum PageBreakType {
-    START_PAGE,
-    END_PAGE,
-  } type;
-  explicit PageBreakRecord(PageBreakType type_in)
-      : signature(kCustomGdiCommentSignature), type(type_in) {
-  }
-  bool IsValid() const {
-    return (signature == kCustomGdiCommentSignature) &&
-           (type >= START_PAGE) && (type <= END_PAGE);
-  }
-};
-
 int CALLBACK IsAlphaBlendUsedEnumProc(HDC,
                                       HANDLETABLE*,
                                       const ENHMETARECORD *record,
                                       int,
                                       LPARAM data) {
   bool* result = reinterpret_cast<bool*>(data);
   if (!result)
     return 0;
   switch (record->iType) {
     case EMR_ALPHABLEND: {
@@ skipping 109 matching lines @@
                                 int size) {
   BOOL supported = FALSE;
   if (ExtEscape(dc, QUERYESCSUPPORT, sizeof(escape),
                 reinterpret_cast<LPCSTR>(&escape), 0, 0) > 0) {
     ExtEscape(dc, escape, size, reinterpret_cast<LPCSTR>(bits),
               sizeof(supported), reinterpret_cast<LPSTR>(&supported));
   }
   return !!supported;
 }
 
-Emf::Emf() : emf_(NULL), hdc_(NULL), page_count_(0) {
+Emf::Emf() : emf_(NULL), hdc_(NULL) {
 }
 
 Emf::~Emf() {
   Close();
 }
 
 void Emf::Close() {
   DCHECK(!hdc_);
   if (emf_)
     DeleteEnhMetaFile(emf_);
@@ skipping 49 matching lines @@
 
 bool Emf::SafePlayback(HDC context) const {
   DCHECK(emf_ && !hdc_);
   XFORM base_matrix;
   if (!GetWorldTransform(context, &base_matrix)) {
     NOTREACHED();
     return false;
   }
   Emf::EnumerationContext playback_context;
   playback_context.base_matrix = &base_matrix;
-  RECT rect = GetPageBounds(1).ToRECT();
-  return EnumEnhMetaFile(context,
+  gfx::Rect bound = GetPageBounds(1);
+  RECT rect = bound.ToRECT();
+  return bound.IsEmpty() ||
+         EnumEnhMetaFile(context,
                          emf_,
                          &Emf::SafePlaybackProc,
                          reinterpret_cast<void*>(&playback_context),
                          &rect) != 0;
 }
 
 gfx::Rect Emf::GetPageBounds(unsigned int page_number) const {
   DCHECK(emf_ && !hdc_);
   DCHECK_EQ(1U, page_number);
   ENHMETAHEADER header;
@@ skipping 197 matching lines @@
         default:
           res = false;
           break;
       }
       break;
     }
     case EMR_SETLAYOUT:
       // Ignore it.
       res = true;
       break;
-    case EMR_GDICOMMENT: {
-      const EMRGDICOMMENT* comment_record =
-          reinterpret_cast<const EMRGDICOMMENT*>(record());
-      if (comment_record->cbData == sizeof(PageBreakRecord)) {
-        const PageBreakRecord* page_break_record =
-            reinterpret_cast<const PageBreakRecord*>(comment_record->Data);
-        if (page_break_record && page_break_record->IsValid()) {
-          if (page_break_record->type == PageBreakRecord::START_PAGE) {
-            res = !!::StartPage(context->hdc);
-            DCHECK_EQ(0, context->dc_on_page_start);
-            context->dc_on_page_start = ::SaveDC(context->hdc);
-          } else if (page_break_record->type == PageBreakRecord::END_PAGE) {
-            DCHECK_NE(0, context->dc_on_page_start);
-            ::RestoreDC(context->hdc, context->dc_on_page_start);
-            context->dc_on_page_start = 0;
-            res = !!::EndPage(context->hdc);
-          } else {
-            res = false;
-            NOTREACHED();
-          }
-        } else {
-          res = Play(context);
-        }
-      } else {
-        res = true;
-      }
-      break;
-    }
     default: {
       res = Play(context);
       break;
     }
   }
   return res;
 }
 
 SkBaseDevice* Emf::StartPageForVectorCanvas(
     const gfx::Size& page_size, const gfx::Rect& content_area,
     const float& scale_factor) {
   if (!StartPage(page_size, content_area, scale_factor))
     return NULL;
 
   return skia::VectorPlatformDeviceEmf::CreateDevice(page_size.width(),
                                                      page_size.height(),
                                                      true, hdc_);
 }
 
 bool Emf::StartPage(const gfx::Size& /*page_size*/,
                     const gfx::Rect& /*content_area*/,
                     const float& /*scale_factor*/) {
-  DCHECK(hdc_);
-  if (!hdc_)
-    return false;
-  page_count_++;
-  PageBreakRecord record(PageBreakRecord::START_PAGE);
-  return !!GdiComment(hdc_, sizeof(record),
-                      reinterpret_cast<const BYTE *>(&record));
+  return true;
 }
 
 bool Emf::FinishPage() {
-  DCHECK(hdc_);
-  if (!hdc_)
-    return false;
-  PageBreakRecord record(PageBreakRecord::END_PAGE);
-  return !!GdiComment(hdc_, sizeof(record),
-                      reinterpret_cast<const BYTE *>(&record));
+  return true;
 }
 
 Emf::Enumerator::Enumerator(const Emf& emf, HDC context, const RECT* rect) {
   items_.clear();
   if (!EnumEnhMetaFile(context,
                        emf.emf(),
                        &Emf::Enumerator::EnhMetaFileProc,
                        reinterpret_cast<void*>(this),
                        rect)) {
     NOTREACHED();
@@ skipping 109 matching lines @@
   RECT rect = page_bounds.ToRECT();
   ::EnumEnhMetaFile(hdc, emf(), &RasterizeAlphaBlendProc, &bitmap_dc, &rect);
 
   result->FinishDocument();
 
   return result.Pass();
 }
 
 
 }  // namespace printing