Merge XFA to PDFium master at 4dc95e7 on 10/28/2014
[pdfium.git] / xfa_test / pdf / pdfium / pdfium_engine.h
1 // Copyright (c) 2012 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 #ifndef PDF_PDFIUM_PDFIUM_ENGINE_H_
6 #define PDF_PDFIUM_PDFIUM_ENGINE_H_
7
8 #include <map>
9 #include <string>
10 #include <utility>
11 #include <vector>
12
13 #include "base/memory/scoped_ptr.h"
14 #include "base/time/time.h"
15 #include "pdf/document_loader.h"
16 #include "pdf/pdf_engine.h"
17 #include "pdf/pdfium/pdfium_page.h"
18 #include "pdf/pdfium/pdfium_range.h"
19 #include "ppapi/cpp/completion_callback.h"
20 #include "ppapi/cpp/dev/buffer_dev.h"
21 #include "ppapi/cpp/image_data.h"
22 #include "ppapi/cpp/point.h"
23 #include "third_party/pdfium/fpdfsdk/include/fpdf_dataavail.h"
24 #include "third_party/pdfium/fpdfsdk/include/fpdf_progressive.h"
25 #include "third_party/pdfium/fpdfsdk/include/fpdfformfill.h"
26 #include "third_party/pdfium/fpdfsdk/include/fpdfview.h"
27
28 #define _TEST_XFA
29 #ifdef _TEST_XFA
30 # if defined(WIN32)
31 #       define FXQA_TESTFILE(filename) "E:/"#filename
32 # else
33 #       define FXQA_TESTFILE(filename) "/home/"#filename
34 # endif
35 #endif
36
37 namespace pp {
38 class KeyboardInputEvent;
39 class MouseInputEvent;
40 }
41
42 namespace chrome_pdf {
43
44 class ShadowMatrix;
45
46 class PDFiumEngine : public PDFEngine,
47                      public DocumentLoader::Client,
48                      public FPDF_FORMFILLINFO,
49                      public IPDF_JSPLATFORM,
50                      public IFSDK_PAUSE {
51  public:
52   explicit PDFiumEngine(PDFEngine::Client* client);
53   virtual ~PDFiumEngine();
54
55   // PDFEngine implementation.
56   virtual bool New(const char* url);
57   virtual bool New(const char* url,
58                    const char* headers);
59   virtual void PageOffsetUpdated(const pp::Point& page_offset);
60   virtual void PluginSizeUpdated(const pp::Size& size);
61   virtual void ScrolledToXPosition(int position);
62   virtual void ScrolledToYPosition(int position);
63   virtual void PrePaint();
64   virtual void Paint(const pp::Rect& rect,
65                      pp::ImageData* image_data,
66                      std::vector<pp::Rect>* ready,
67                      std::vector<pp::Rect>* pending);
68   virtual void PostPaint();
69   virtual bool HandleDocumentLoad(const pp::URLLoader& loader);
70   virtual bool HandleEvent(const pp::InputEvent& event);
71   virtual uint32_t QuerySupportedPrintOutputFormats();
72   virtual void PrintBegin();
73   virtual pp::Resource PrintPages(
74       const PP_PrintPageNumberRange_Dev* page_ranges,
75       uint32_t page_range_count,
76       const PP_PrintSettings_Dev& print_settings);
77   virtual void PrintEnd();
78   virtual void StartFind(const char* text, bool case_sensitive);
79   virtual bool SelectFindResult(bool forward);
80   virtual void StopFind();
81   virtual void ZoomUpdated(double new_zoom_level);
82   virtual void RotateClockwise();
83   virtual void RotateCounterclockwise();
84   virtual std::string GetSelectedText();
85   virtual std::string GetLinkAtPosition(const pp::Point& point);
86   virtual bool IsSelecting();
87   virtual bool HasPermission(DocumentPermission permission) const;
88   virtual void SelectAll();
89   virtual int GetNumberOfPages();
90   virtual int GetNamedDestinationPage(const std::string& destination);
91   virtual int GetFirstVisiblePage();
92   virtual int GetMostVisiblePage();
93   virtual pp::Rect GetPageRect(int index);
94   virtual pp::Rect GetPageContentsRect(int index);
95   virtual int GetVerticalScrollbarYPosition() { return position_.y(); }
96   virtual void PaintThumbnail(pp::ImageData* image_data, int index);
97   virtual void SetGrayscale(bool grayscale);
98   virtual void OnCallback(int id);
99   virtual std::string GetPageAsJSON(int index);
100   virtual bool GetPrintScaling();
101   virtual void AppendBlankPages(int num_pages);
102   virtual void AppendPage(PDFEngine* engine, int index);
103   virtual pp::Point GetScrollPosition();
104   virtual void SetScrollPosition(const pp::Point& position);
105   virtual bool IsProgressiveLoad();
106
107   // DocumentLoader::Client implementation.
108   virtual pp::Instance* GetPluginInstance();
109   virtual pp::URLLoader CreateURLLoader();
110   virtual void OnPartialDocumentLoaded();
111   virtual void OnPendingRequestComplete();
112   virtual void OnNewDataAvailable();
113   virtual void OnDocumentComplete();
114
115   void UnsupportedFeature(int type);
116
117   std::string current_find_text() const { return current_find_text_; }
118
119   FPDF_DOCUMENT doc() { return doc_; }
120   FPDF_FORMHANDLE form() { return form_; }
121
122  private:
123   // This helper class is used to detect the difference in selection between
124   // construction and destruction.  At destruction, it invalidates all the
125   // parts that are newly selected, along with all the parts that used to be
126   // selected but are not anymore.
127   class SelectionChangeInvalidator {
128    public:
129     explicit SelectionChangeInvalidator(PDFiumEngine* engine);
130     ~SelectionChangeInvalidator();
131    private:
132     // Sets the given container to the all the currently visible selection
133     // rectangles, in screen coordinates.
134     void GetVisibleSelectionsScreenRects(std::vector<pp::Rect>* rects);
135
136     PDFiumEngine* engine_;
137     // Screen rectangles that were selected on construction.
138     std::vector<pp::Rect> old_selections_;
139     // The origin at the time this object was constructed.
140     pp::Point previous_origin_;
141   };
142
143   // Used to store mouse down state to handle it in other mouse event handlers.
144   class MouseDownState {
145    public:
146     MouseDownState(const PDFiumPage::Area& area,
147                    const PDFiumPage::LinkTarget& target);
148     ~MouseDownState();
149
150     void Set(const PDFiumPage::Area& area,
151              const PDFiumPage::LinkTarget& target);
152     void Reset();
153     bool Matches(const PDFiumPage::Area& area,
154                  const PDFiumPage::LinkTarget& target) const;
155
156    private:
157     PDFiumPage::Area area_;
158     PDFiumPage::LinkTarget target_;
159
160     DISALLOW_COPY_AND_ASSIGN(MouseDownState);
161   };
162
163   friend class SelectionChangeInvalidator;
164
165   struct FileAvail : public FX_FILEAVAIL {
166     DocumentLoader* loader;
167   };
168
169   struct DownloadHints : public FX_DOWNLOADHINTS {
170     DocumentLoader* loader;
171   };
172
173   // PDFium interface to get block of data.
174   static int GetBlock(void* param, unsigned long position,
175                       unsigned char* buffer, unsigned long size);
176
177   // PDFium interface to check is block of data is available.
178   static bool IsDataAvail(FX_FILEAVAIL* param,
179                           size_t offset, size_t size);
180
181   // PDFium interface to request download of the block of data.
182   static void AddSegment(FX_DOWNLOADHINTS* param,
183                          size_t offset, size_t size);
184
185   // We finished getting the pdf file, so load it. This will complete
186   // asynchronously (due to password fetching) and may be run multiple times.
187   void LoadDocument();
188
189   // Try loading the document. Returns true if the document is successfully
190   // loaded or is already loaded otherwise it will return false. If
191   // |with_password| is set to true, the document will be loaded with
192   // |password|. If the document could not be loaded and needs a password,
193   // |needs_password| will be set to true.
194   bool TryLoadingDoc(bool with_password,
195                      const std::string& password,
196                      bool* needs_password);
197
198   // Ask the user for the document password and then continue loading the
199   // document.
200   void GetPasswordAndLoad();
201
202   // Called when the password has been retrieved.
203   void OnGetPasswordComplete(int32_t result,
204                              const pp::Var& password);
205
206   // Continues loading the document when the password has been retrieved, or if
207   // there is no password.
208   void ContinueLoadingDocument(bool has_password,
209                                const std::string& password);
210
211   // Finish loading the document and notify the client that the document has
212   // been loaded. This should only be run after |doc_| has been loaded and the
213   // document is fully downloaded. If this has been run once, it will result in
214   // a no-op.
215   void FinishLoadingDocument();
216
217   // Loads information about the pages in the document and calculate the
218   // document size.
219   void LoadPageInfo(bool reload);
220
221   // Calculate which pages should be displayed right now.
222   void CalculateVisiblePages();
223
224   // Returns true iff the given page index is visible.  CalculateVisiblePages
225   // must have been called first.
226   bool IsPageVisible(int index) const;
227
228   // Checks if a page is now available, and if so marks it as such and returns
229   // true.  Otherwise, it will return false and will add the index to the given
230   // array if it's not already there.
231   bool CheckPageAvailable(int index, std::vector<int>* pending);
232
233   // Helper function to get a given page's size in pixels.  This is not part of
234   // PDFiumPage because we might not have that structure when we need this.
235   pp::Size GetPageSize(int index);
236
237   void UpdateTickMarks();
238
239   // Called to continue searching so we don't block the main thread.
240   void ContinueFind(int32_t result);
241
242   // Inserts a find result into find_results_, which is sorted.
243   void AddFindResult(const PDFiumRange& result);
244
245   // Search a page using PDFium's methods.  Doesn't work with unicode.  This
246   // function is just kept arount in case PDFium code is fixed.
247   void SearchUsingPDFium(const base::string16& term,
248                          bool case_sensitive,
249                          bool first_search,
250                          int character_to_start_searching_from,
251                          int current_page);
252
253   // Search a page ourself using ICU.
254   void SearchUsingICU(const base::string16& term,
255                       bool case_sensitive,
256                       bool first_search,
257                       int character_to_start_searching_from,
258                       int current_page);
259
260   // Input event handlers.
261   bool OnMouseDown(const pp::MouseInputEvent& event);
262   bool OnMouseUp(const pp::MouseInputEvent& event);
263   bool OnMouseMove(const pp::MouseInputEvent& event);
264   bool OnKeyDown(const pp::KeyboardInputEvent& event);
265   bool OnKeyUp(const pp::KeyboardInputEvent& event);
266   bool OnChar(const pp::KeyboardInputEvent& event);
267
268   FPDF_DOCUMENT CreateSinglePageRasterPdf(
269       double source_page_width,
270       double source_page_height,
271       const PP_PrintSettings_Dev& print_settings,
272       PDFiumPage* page_to_print);
273
274   pp::Buffer_Dev PrintPagesAsRasterPDF(
275       const PP_PrintPageNumberRange_Dev* page_ranges,
276       uint32_t page_range_count,
277       const PP_PrintSettings_Dev& print_settings);
278
279   pp::Buffer_Dev PrintPagesAsPDF(const PP_PrintPageNumberRange_Dev* page_ranges,
280                                  uint32_t page_range_count,
281                                  const PP_PrintSettings_Dev& print_settings);
282
283   pp::Buffer_Dev GetFlattenedPrintData(const FPDF_DOCUMENT& doc);
284   void FitContentsToPrintableAreaIfRequired(
285       const FPDF_DOCUMENT& doc,
286       const PP_PrintSettings_Dev& print_settings);
287   void SaveSelectedFormForPrint();
288
289   // Given a mouse event, returns which page and character location it's closest
290   // to.
291   PDFiumPage::Area GetCharIndex(const pp::MouseInputEvent& event,
292                                 int* page_index,
293                                 int* char_index,
294                                 PDFiumPage::LinkTarget* target);
295   PDFiumPage::Area GetCharIndex(const pp::Point& point,
296                                 int* page_index,
297                                 int* char_index,
298                                 PDFiumPage::LinkTarget* target);
299
300   void OnSingleClick(int page_index, int char_index);
301   void OnMultipleClick(int click_count, int page_index, int char_index);
302
303   // Starts a progressive paint operation given a rectangle in screen
304   // coordinates. Returns the index in progressive_rects_.
305   int StartPaint(int page_index, const pp::Rect& dirty);
306
307   // Continues a paint operation that was started earlier.  Returns true if the
308   // paint is done, or false if it needs to be continued.
309   bool ContinuePaint(int progressive_index, pp::ImageData* image_data);
310
311   // Called once PDFium is finished rendering a page so that we draw our
312   // borders, highlighting etc.
313   void FinishPaint(int progressive_index, pp::ImageData* image_data);
314
315   // Stops any paints that are in progress.
316   void CancelPaints();
317
318   // Invalidates all pages. Use this when some global parameter, such as page
319   // orientation, has changed.
320   void InvalidateAllPages();
321
322   // If the page is narrower than the document size, paint the extra space
323   // with the page background.
324   void FillPageSides(int progressive_index);
325
326   void PaintPageShadow(int progressive_index, pp::ImageData* image_data);
327
328   // Highlight visible find results and selections.
329   void DrawSelections(int progressive_index, pp::ImageData* image_data);
330
331   // Paints an page that hasn't finished downloading.
332   void PaintUnavailablePage(int page_index,
333                             const pp::Rect& dirty,
334                             pp::ImageData* image_data);
335
336   // Given a page index, returns the corresponding index in progressive_rects_,
337   // or -1 if it doesn't exist.
338   int GetProgressiveIndex(int page_index) const;
339
340   // Creates a FPDF_BITMAP from a rectangle in screen coordinates.
341   FPDF_BITMAP CreateBitmap(const pp::Rect& rect,
342                            pp::ImageData* image_data) const;
343
344   // Given a rectangle in screen coordinates, returns the coordinates in the
345   // units that PDFium rendering functions expect.
346   void GetPDFiumRect(int page_index, const pp::Rect& rect, int* start_x,
347                      int* start_y, int* size_x, int* size_y) const;
348
349   // Returns the rendering flags to pass to PDFium.
350   int GetRenderingFlags() const;
351
352   // Returns the currently visible rectangle in document coordinates.
353   pp::Rect GetVisibleRect() const;
354
355   // Returns a page's rect in screen coordinates, as well as its surrounding
356   // border areas and bottom separator.
357   pp::Rect GetPageScreenRect(int page_index) const;
358
359   // Given a rectangle in document coordinates, returns the rectange into screen
360   // coordinates (i.e. 0,0 is top left corner of plugin area).  If it's not
361   // visible, an empty rectangle is returned.
362   pp::Rect GetScreenRect(const pp::Rect& rect) const;
363
364   // Highlights the given rectangle.
365   void Highlight(void* buffer,
366                  int stride,
367                  const pp::Rect& rect,
368                  std::vector<pp::Rect>* highlighted_rects);
369
370   // Helper function to convert a device to page coordinates.  If the page is
371   // not yet loaded, page_x and page_y will be set to 0.
372   void DeviceToPage(int page_index,
373                     float device_x,
374                     float device_y,
375                     double* page_x,
376                     double* page_y);
377
378   // Helper function to get the index of a given FPDF_PAGE.  Returns -1 if not
379   // found.
380   int GetVisiblePageIndex(FPDF_PAGE page);
381
382   // Helper function to change the current page, running page open/close
383   // triggers as necessary.
384   void SetCurrentPage(int index);
385
386   // Transform |page| contents to fit in the selected printer paper size.
387   void TransformPDFPageForPrinting(FPDF_PAGE page,
388                                    const PP_PrintSettings_Dev& print_settings);
389
390   void DrawPageShadow(const pp::Rect& page_rect,
391                       const pp::Rect& shadow_rect,
392                       const pp::Rect& clip_rect,
393                       pp::ImageData* image_data);
394
395   void GetRegion(const pp::Point& location,
396                  pp::ImageData* image_data,
397                  void** region,
398                  int* stride) const;
399
400   // Called when the selection changes.
401   void OnSelectionChanged();
402
403   // FPDF_FORMFILLINFO callbacks.
404   static void Form_Invalidate(FPDF_FORMFILLINFO* param,
405                               FPDF_PAGE page,
406                               double left,
407                               double top,
408                               double right,
409                               double bottom);
410   static void Form_OutputSelectedRect(FPDF_FORMFILLINFO* param,
411                                       FPDF_PAGE page,
412                                       double left,
413                                       double top,
414                                       double right,
415                                       double bottom);
416   static void Form_SetCursor(FPDF_FORMFILLINFO* param, int cursor_type);
417   static int Form_SetTimer(FPDF_FORMFILLINFO* param,
418                            int elapse,
419                            TimerCallback timer_func);
420   static void Form_KillTimer(FPDF_FORMFILLINFO* param, int timer_id);
421   static FPDF_SYSTEMTIME Form_GetLocalTime(FPDF_FORMFILLINFO* param);
422   static void Form_OnChange(FPDF_FORMFILLINFO* param);
423   static FPDF_PAGE Form_GetPage(FPDF_FORMFILLINFO* param,
424                                 FPDF_DOCUMENT document,
425                                 int page_index);
426   static FPDF_PAGE Form_GetCurrentPage(FPDF_FORMFILLINFO* param,
427                                        FPDF_DOCUMENT document);
428   static int Form_GetRotation(FPDF_FORMFILLINFO* param, FPDF_PAGE page);
429   static void Form_ExecuteNamedAction(FPDF_FORMFILLINFO* param,
430                                       FPDF_BYTESTRING named_action);
431   static void Form_SetTextFieldFocus(FPDF_FORMFILLINFO* param,
432                                      FPDF_WIDESTRING value,
433                                      FPDF_DWORD valueLen,
434                                      FPDF_BOOL is_focus);
435   static void Form_DoURIAction(FPDF_FORMFILLINFO* param, FPDF_BYTESTRING uri);
436   static void Form_DoGoToAction(FPDF_FORMFILLINFO* param,
437                                 int page_index,
438                                 int zoom_mode,
439                                 float* position_array,
440                                 int size_of_array);
441
442   // IPDF_JSPLATFORM callbacks.
443   static int Form_Alert(IPDF_JSPLATFORM* param,
444                         FPDF_WIDESTRING message,
445                         FPDF_WIDESTRING title,
446                         int type,
447                         int icon);
448   static void Form_Beep(IPDF_JSPLATFORM* param, int type);
449   static int Form_Response(IPDF_JSPLATFORM* param,
450                            FPDF_WIDESTRING question,
451                            FPDF_WIDESTRING title,
452                            FPDF_WIDESTRING default_response,
453                            FPDF_WIDESTRING label,
454                            FPDF_BOOL password,
455                            void* response,
456                            int length);
457   static int Form_GetFilePath(IPDF_JSPLATFORM* param,
458                               void* file_path,
459                               int length);
460   static void Form_Mail(IPDF_JSPLATFORM* param,
461                         void* mail_data,
462                         int length,
463                         FPDF_BOOL ui,
464                         FPDF_WIDESTRING to,
465                         FPDF_WIDESTRING subject,
466                         FPDF_WIDESTRING cc,
467                         FPDF_WIDESTRING bcc,
468                         FPDF_WIDESTRING message);
469   static void Form_Print(IPDF_JSPLATFORM* param,
470                          FPDF_BOOL ui,
471                          int start,
472                          int end,
473                          FPDF_BOOL silent,
474                          FPDF_BOOL shrink_to_fit,
475                          FPDF_BOOL print_as_image,
476                          FPDF_BOOL reverse,
477                          FPDF_BOOL annotations);
478   static void Form_SubmitForm(IPDF_JSPLATFORM* param,
479                               void* form_data,
480                               int length,
481                               FPDF_WIDESTRING url);
482   static void Form_GotoPage(IPDF_JSPLATFORM* param, int page_number);
483   static int Form_Browse(IPDF_JSPLATFORM* param, void* file_path, int length);
484 #ifdef _TEST_XFA
485   static void Form_EmailTo(FPDF_FORMFILLINFO* pThis, FPDF_FILEHANDLER* fileHandler, 
486           FPDF_WIDESTRING to, FPDF_WIDESTRING subject, FPDF_WIDESTRING cc, FPDF_WIDESTRING bcc, FPDF_WIDESTRING message);
487   static void Form_DisplayCaret(FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, FPDF_BOOL bVisible, double left, double top, double right, double bottom);
488   //static int Form_GetCurDocumentIndex(FPDF_FORMFILLINFO* pThis);
489   //static int Form_GetDocumentCount(FPDF_FORMFILLINFO* pThis);
490   static void Form_SetCurrentPage(FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document, int iCurPage);
491   static int Form_GetCurrentPageIndex(FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document);
492   static void Form_GetPageViewRect(FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, double* left, double* top, double* right, double* bottom);
493   static int Form_GetPlatform(FPDF_FORMFILLINFO* pThis, void* platform, int length);
494   static FPDF_BOOL Form_PopupMenu(FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, FPDF_WIDGET hWidget, int menuFlag, float x, float y);
495   static FPDF_BOOL Form_PostRequestURL(FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING wsURL, FPDF_WIDESTRING wsData, FPDF_WIDESTRING wsContentType, FPDF_WIDESTRING wsEncode, FPDF_WIDESTRING wsHeader, FPDF_BSTR* respone);
496   static FPDF_BOOL Form_PutRequestURL(FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING wsURL, FPDF_WIDESTRING wsData, FPDF_WIDESTRING wsEncode);
497   //static FPDF_BOOL Form_ShowFileDialog(FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING wsTitle, FPDF_WIDESTRING wsFilter, FPDF_BOOL isOpen, FPDF_STRINGHANDLE pathArr);
498   static void Form_UploadTo(FPDF_FORMFILLINFO* pThis, FPDF_FILEHANDLER* fileHandler, int fileFlag, FPDF_WIDESTRING uploadTo);
499   static FPDF_LPFILEHANDLER Form_DownloadFromURL(FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING URL);
500   //static FPDF_BOOL MyForm_GetFilePath(FPDF_FORMFILLINFO* pThis, FPDF_FILEHANDLER* pFileHandler, void* filePath, int length);
501   static FPDF_FILEHANDLER* Form_OpenFile(FPDF_FORMFILLINFO* pThis, int fileFlag, FPDF_WIDESTRING wsURL, const char* mode);
502   static void Form_GotoURL(FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document, FPDF_WIDESTRING wsURL);
503   static int Form_GetLanguage(FPDF_FORMFILLINFO* pThis, void* language, int length);
504 #endif // _TEST_XFA
505   // IFSDK_PAUSE callbacks
506   static FPDF_BOOL Pause_NeedToPauseNow(IFSDK_PAUSE* param);
507
508   PDFEngine::Client* client_;
509   pp::Size document_size_;  // Size of document in pixels.
510
511   // The scroll position in screen coordinates.
512   pp::Point position_;
513   // The offset of the page into the viewport.
514   pp::Point page_offset_;
515   // The plugin size in screen coordinates.
516   pp::Size plugin_size_;
517   double current_zoom_;
518   unsigned int current_rotation_;
519
520   DocumentLoader doc_loader_;  // Main document's loader.
521   std::string url_;
522   std::string headers_;
523   pp::CompletionCallbackFactory<PDFiumEngine> find_factory_;
524
525   pp::CompletionCallbackFactory<PDFiumEngine> password_factory_;
526   int32_t password_tries_remaining_;
527
528   // The current text used for searching.
529   std::string current_find_text_;
530
531   // The PDFium wrapper object for the document.
532   FPDF_DOCUMENT doc_;
533
534   // The PDFium wrapper for form data.  Used even if there are no form controls
535   // on the page.
536   FPDF_FORMHANDLE form_;
537
538   // The page(s) of the document. Store a vector of pointers so that when the
539   // vector is resized we don't close the pages that are used in pending
540   // paints.
541   std::vector<PDFiumPage*> pages_;
542
543   // The indexes of the pages currently visible.
544   std::vector<int> visible_pages_;
545
546   // The indexes of the pages pending download.
547   std::vector<int> pending_pages_;
548
549   // During handling of input events we don't want to unload any pages in
550   // callbacks to us from PDFium, since the current page can change while PDFium
551   // code still has a pointer to it.
552   bool defer_page_unload_;
553   std::vector<int> deferred_page_unloads_;
554
555   // Used for selection.  There could be more than one range if selection spans
556   // more than one page.
557   std::vector<PDFiumRange> selection_;
558   // True if we're in the middle of selection.
559   bool selecting_;
560
561   MouseDownState mouse_down_state_;
562
563   // Used for searching.
564   typedef std::vector<PDFiumRange> FindResults;
565   FindResults find_results_;
566   // Which page to search next.
567   int next_page_to_search_;
568   // Where to stop searching.
569   int last_page_to_search_;
570   int last_character_index_to_search_;  // -1 if search until end of page.
571   // Which result the user has currently selected.
572   int current_find_index_;
573   // Where to resume searching.
574   int resume_find_index_;
575
576   // Permissions bitfield.
577   unsigned long permissions_;
578
579   // Interface structure to provide access to document stream.
580   FPDF_FILEACCESS file_access_;
581   // Interface structure to check data availability in the document stream.
582   FileAvail file_availability_;
583   // Interface structure to request data chunks from the document stream.
584   DownloadHints download_hints_;
585   // Pointer to the document availability interface.
586   FPDF_AVAIL fpdf_availability_;
587
588   pp::Size default_page_size_;
589
590   // Used to manage timers that form fill API needs.  The pair holds the timer
591   // period, in ms, and the callback function.
592   std::map<int, std::pair<int, TimerCallback> > timers_;
593   int next_timer_id_;
594
595   // Holds the page index of the last page that the mouse clicked on.
596   int last_page_mouse_down_;
597
598   // Holds the page index of the first visible page; refreshed by calling
599   // CalculateVisiblePages()
600   int first_visible_page_;
601
602   // Holds the page index of the most visible page; refreshed by calling
603   // CalculateVisiblePages()
604   int most_visible_page_;
605
606   // Set to true after FORM_DoDocumentJSAction/FORM_DoDocumentOpenAction have
607   // been called. Only after that can we call FORM_DoPageAAction.
608   bool called_do_document_action_;
609
610   // Records parts of form fields that need to be highlighted at next paint, in
611   // screen coordinates.
612   std::vector<pp::Rect> form_highlights_;
613
614   // Whether to render in grayscale or in color.
615   bool render_grayscale_;
616
617   // The link currently under the cursor.
618   std::string link_under_cursor_;
619
620   // Pending progressive paints.
621   struct ProgressivePaint {
622     pp::Rect rect;  // In screen coordinates.
623     FPDF_BITMAP bitmap;
624     int page_index;
625     // Temporary used to figure out if in a series of Paint() calls whether this
626     // pending paint was updated or not.
627     int painted_;
628   };
629   std::vector<ProgressivePaint> progressive_paints_;
630
631   // Keeps track of when we started the last progressive paint, so that in our
632   // callback we can determine if we need to pause.
633   base::Time last_progressive_start_time_;
634
635   // The timeout to use for the current progressive paint.
636   int progressive_paint_timeout_;
637
638   // Shadow matrix for generating the page shadow bitmap.
639   scoped_ptr<ShadowMatrix> page_shadow_;
640
641   // Set to true if the user is being prompted for their password. Will be set
642   // to false after the user finishes getting their password.
643   bool getting_password_;
644 };
645
646 // Create a local variable of this when calling PDFium functions which can call
647 // our global callback when an unsupported feature is reached.
648 class ScopedUnsupportedFeature {
649  public:
650   explicit ScopedUnsupportedFeature(PDFiumEngine* engine);
651   ~ScopedUnsupportedFeature();
652  private:
653   PDFiumEngine* engine_;
654   PDFiumEngine* old_engine_;
655 };
656
657 class PDFiumEngineExports : public PDFEngineExports {
658  public:
659   PDFiumEngineExports() {}
660 #if defined(OS_WIN)
661   // See the definition of RenderPDFPageToDC in pdf.cc for details.
662   virtual bool RenderPDFPageToDC(const void* pdf_buffer,
663                                  int buffer_size,
664                                  int page_number,
665                                  const RenderingSettings& settings,
666                                  HDC dc);
667 #endif  // OS_WIN
668   virtual bool RenderPDFPageToBitmap(const void* pdf_buffer,
669                                      int pdf_buffer_size,
670                                      int page_number,
671                                      const RenderingSettings& settings,
672                                      void* bitmap_buffer);
673
674   virtual bool GetPDFDocInfo(const void* pdf_buffer,
675                              int buffer_size,
676                              int* page_count,
677                              double* max_page_width);
678
679   // See the definition of GetPDFPageSizeByIndex in pdf.cc for details.
680   virtual bool GetPDFPageSizeByIndex(const void* pdf_buffer,
681                                      int pdf_buffer_size, int page_number,
682                                      double* width, double* height);
683 };
684
685 }  // namespace chrome_pdf
686
687 #endif  // PDF_PDFIUM_PDFIUM_ENGINE_H_