src/ppapi/cpp/private/pdf.cc

   1 // Copyright (c) 2013 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 "ppapi/cpp/private/pdf.h"
   6
   7 #include "ppapi/c/trusted/ppb_browser_font_trusted.h"
   8 #include "ppapi/cpp/image_data.h"
   9 #include "ppapi/cpp/instance_handle.h"
  10 #include "ppapi/cpp/module_impl.h"
  11 #include "ppapi/cpp/var.h"
  12
  13 namespace pp {
  14
  15 namespace {
  16
  17 template <> const char* interface_name<PPB_PDF>() {
  18   return PPB_PDF_INTERFACE;
  19 }
  20
  21 }  // namespace
  22
  23 // static
  24 bool PDF::IsAvailable() {
  25   return has_interface<PPB_PDF>();
  26 }
  27
  28 // static
  29 Var PDF::GetLocalizedString(const InstanceHandle& instance,
  30                             PP_ResourceString string_id) {
  31   if (has_interface<PPB_PDF>()) {
  32     return Var(PASS_REF,
  33                get_interface<PPB_PDF>()->GetLocalizedString(
  34                    instance.pp_instance(), string_id));
  35   }
  36   return Var();
  37 }
  38
  39 // static
  40 ImageData PDF::GetResourceImage(const InstanceHandle& instance,
  41                                 PP_ResourceImage image_id) {
  42   if (has_interface<PPB_PDF>()) {
  43     return ImageData(PASS_REF,
  44                      get_interface<PPB_PDF>()->GetResourceImage(
  45                          instance.pp_instance(), image_id));
  46   }
  47   return ImageData();
  48 }
  49
  50 // static
  51 PP_Resource PDF::GetFontFileWithFallback(
  52     const InstanceHandle& instance,
  53     const PP_FontDescription_Dev* description,
  54     PP_PrivateFontCharset charset) {
  55   if (has_interface<PPB_PDF>()) {
  56     PP_BrowserFont_Trusted_Description converted_desc;
  57     converted_desc.face = description->face;
  58     converted_desc.family = static_cast<PP_BrowserFont_Trusted_Family>(
  59         description->family);
  60     converted_desc.size = description->size;
  61     converted_desc.weight = static_cast<PP_BrowserFont_Trusted_Weight>(
  62         description->weight);
  63     converted_desc.italic = description->italic;
  64     converted_desc.small_caps = description->small_caps;
  65     converted_desc.letter_spacing = description->letter_spacing;
  66     converted_desc.word_spacing = description->word_spacing;
  67     return get_interface<PPB_PDF>()->GetFontFileWithFallback(
  68         instance.pp_instance(), &converted_desc, charset);
  69   }
  70   return 0;
  71 }
  72
  73 // static
  74 PP_Resource PDF::GetFontFileWithFallback(
  75     const InstanceHandle& instance,
  76     const PP_BrowserFont_Trusted_Description* description,
  77     PP_PrivateFontCharset charset) {
  78   if (has_interface<PPB_PDF>()) {
  79     return get_interface<PPB_PDF>()->GetFontFileWithFallback(
  80         instance.pp_instance(), description, charset);
  81   }
  82   return 0;
  83 }
  84
  85 // static
  86 bool PDF::GetFontTableForPrivateFontFile(PP_Resource font_file,
  87                                          uint32_t table,
  88                                          void* output,
  89                                          uint32_t* output_length) {
  90   if (has_interface<PPB_PDF>()) {
  91     return get_interface<PPB_PDF>()->GetFontTableForPrivateFontFile(font_file,
  92         table, output, output_length);
  93   }
  94   return false;
  95 }
  96
  97 // static
  98 void PDF::SearchString(const InstanceHandle& instance,
  99                        const unsigned short* string,
 100                        const unsigned short* term,
 101                        bool case_sensitive,
 102                        PP_PrivateFindResult** results,
 103                        int* count) {
 104   if (has_interface<PPB_PDF>()) {
 105     get_interface<PPB_PDF>()->SearchString(instance.pp_instance(), string,
 106         term, case_sensitive, results, count);
 107   }
 108 }
 109
 110 // static
 111 void PDF::DidStartLoading(const InstanceHandle& instance) {
 112   if (has_interface<PPB_PDF>())
 113     get_interface<PPB_PDF>()->DidStartLoading(instance.pp_instance());
 114 }
 115
 116 // static
 117 void PDF::DidStopLoading(const InstanceHandle& instance) {
 118   if (has_interface<PPB_PDF>())
 119     get_interface<PPB_PDF>()->DidStopLoading(instance.pp_instance());
 120 }
 121
 122 // static
 123 void PDF::SetContentRestriction(const InstanceHandle& instance,
 124                                 int restrictions) {
 125   if (has_interface<PPB_PDF>()) {
 126     get_interface<PPB_PDF>()->SetContentRestriction(instance.pp_instance(),
 127                                                     restrictions);
 128   }
 129 }
 130
 131 // static
 132 void PDF::HistogramPDFPageCount(const InstanceHandle& instance,
 133                                 int count) {
 134   if (has_interface<PPB_PDF>())
 135     get_interface<PPB_PDF>()->HistogramPDFPageCount(instance.pp_instance(),
 136                                                     count);
 137 }
 138
 139 // static
 140 void PDF::UserMetricsRecordAction(const InstanceHandle& instance,
 141                                   const Var& action) {
 142   if (has_interface<PPB_PDF>()) {
 143     get_interface<PPB_PDF>()->UserMetricsRecordAction(instance.pp_instance(),
 144                                                       action.pp_var());
 145   }
 146 }
 147
 148 // static
 149 void PDF::HasUnsupportedFeature(const InstanceHandle& instance) {
 150   if (has_interface<PPB_PDF>())
 151     get_interface<PPB_PDF>()->HasUnsupportedFeature(instance.pp_instance());
 152 }
 153
 154 // static
 155 void PDF::SaveAs(const InstanceHandle& instance) {
 156   if (has_interface<PPB_PDF>())
 157     get_interface<PPB_PDF>()->SaveAs(instance.pp_instance());
 158 }
 159
 160 // static
 161 void PDF::Print(const InstanceHandle& instance) {
 162   if (has_interface<PPB_PDF>())
 163     get_interface<PPB_PDF>()->Print(instance.pp_instance());
 164 }
 165
 166 // static
 167 bool PDF::IsFeatureEnabled(const InstanceHandle& instance,
 168                            PP_PDFFeature feature) {
 169   if (has_interface<PPB_PDF>())
 170     return PP_ToBool(get_interface<PPB_PDF>()->IsFeatureEnabled(
 171         instance.pp_instance(), feature));
 172   return false;
 173 }
 174
 175 // static
 176 ImageData PDF::GetResourceImageForScale(const InstanceHandle& instance,
 177                                         PP_ResourceImage image_id,
 178                                         float scale) {
 179   if (has_interface<PPB_PDF>()) {
 180     return ImageData(PASS_REF,
 181                      get_interface<PPB_PDF>()->GetResourceImageForScale(
 182                          instance.pp_instance(), image_id, scale));
 183   }
 184   return ImageData();
 185 }
 186
 187 // static
 188 Var PDF::ModalPromptForPassword(const InstanceHandle& instance,
 189                                 Var message) {
 190   if (has_interface<PPB_PDF>()) {
 191     return Var(PASS_REF,
 192                get_interface<PPB_PDF>()->ModalPromptForPassword(
 193                    instance.pp_instance(),
 194                    message.pp_var()));
 195   }
 196   return Var();
 197 }
 198
 199 // static
 200 bool PDF::IsOutOfProcess(const InstanceHandle& instance) {
 201   if (has_interface<PPB_PDF>()) {
 202     return PP_ToBool(get_interface<PPB_PDF>()->IsOutOfProcess(
 203         instance.pp_instance()));
 204   }
 205   return false;
 206 }
 207
 208 // static
 209 void PDF::SetSelectedText(const InstanceHandle& instance,
 210                           const char* selected_text) {
 211   if (has_interface<PPB_PDF>()) {
 212     get_interface<PPB_PDF>()->SetSelectedText(instance.pp_instance(),
 213                                               selected_text);
 214   }
 215 }
 216
 217 }  // namespace pp