| OLD | NEW |
|---|
| (Empty) |
| 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_INSTANCE_H_ | |
| 6 #define PDF_INSTANCE_H_ | |
| 7 | |
| 8 #include <queue> | |
| 9 #include <set> | |
| 10 #include <string> | |
| 11 #include <utility> | |
| 12 #include <vector> | |
| 13 | |
| 14 #include "base/memory/scoped_ptr.h" | |
| 15 #include "pdf/button.h" | |
| 16 #include "pdf/fading_controls.h" | |
| 17 #include "pdf/page_indicator.h" | |
| 18 #include "pdf/paint_manager.h" | |
| 19 #include "pdf/pdf_engine.h" | |
| 20 #include "pdf/preview_mode_client.h" | |
| 21 #include "pdf/progress_control.h" | |
| 22 #include "pdf/thumbnail_control.h" | |
| 23 | |
| 24 #include "ppapi/c/private/ppb_pdf.h" | |
| 25 #include "ppapi/c/private/ppp_pdf.h" | |
| 26 #include "ppapi/cpp/dev/printing_dev.h" | |
| 27 #include "ppapi/cpp/dev/scriptable_object_deprecated.h" | |
| 28 #include "ppapi/cpp/dev/scrollbar_dev.h" | |
| 29 #include "ppapi/cpp/dev/selection_dev.h" | |
| 30 #include "ppapi/cpp/dev/widget_client_dev.h" | |
| 31 #include "ppapi/cpp/dev/zoom_dev.h" | |
| 32 #include "ppapi/cpp/graphics_2d.h" | |
| 33 #include "ppapi/cpp/image_data.h" | |
| 34 #include "ppapi/cpp/input_event.h" | |
| 35 #include "ppapi/cpp/private/find_private.h" | |
| 36 #include "ppapi/cpp/private/instance_private.h" | |
| 37 #include "ppapi/cpp/private/var_private.h" | |
| 38 #include "ppapi/cpp/url_loader.h" | |
| 39 #include "ppapi/utility/completion_callback_factory.h" | |
| 40 | |
| 41 namespace pp { | |
| 42 class TextInput_Dev; | |
| 43 } | |
| 44 | |
| 45 namespace chrome_pdf { | |
| 46 | |
| 47 struct ToolbarButtonInfo; | |
| 48 | |
| 49 class Instance : public pp::InstancePrivate, | |
| 50 public pp::Find_Private, | |
| 51 public pp::Printing_Dev, | |
| 52 public pp::Selection_Dev, | |
| 53 public pp::WidgetClient_Dev, | |
| 54 public pp::Zoom_Dev, | |
| 55 public PaintManager::Client, | |
| 56 public PDFEngine::Client, | |
| 57 public PreviewModeClient::Client, | |
| 58 public ControlOwner { | |
| 59 public: | |
| 60 explicit Instance(PP_Instance instance); | |
| 61 ~Instance() override; | |
| 62 | |
| 63 // pp::Instance implementation. | |
| 64 bool Init(uint32_t argc, | |
| 65 const char* argn[], | |
| 66 const char* argv[]) override; | |
| 67 bool HandleDocumentLoad(const pp::URLLoader& loader) override; | |
| 68 bool HandleInputEvent(const pp::InputEvent& event) override; | |
| 69 void DidChangeView(const pp::View& view) override; | |
| 70 pp::Var GetInstanceObject() override; | |
| 71 | |
| 72 // pp::Find_Private implementation. | |
| 73 bool StartFind(const std::string& text, bool case_sensitive) override; | |
| 74 void SelectFindResult(bool forward) override; | |
| 75 void StopFind() override; | |
| 76 | |
| 77 // pp::PaintManager::Client implementation. | |
| 78 void OnPaint(const std::vector<pp::Rect>& paint_rects, | |
| 79 std::vector<PaintManager::ReadyRect>* ready, | |
| 80 std::vector<pp::Rect>* pending) override; | |
| 81 | |
| 82 // pp::Printing_Dev implementation. | |
| 83 uint32_t QuerySupportedPrintOutputFormats() override; | |
| 84 int32_t PrintBegin( | |
| 85 const PP_PrintSettings_Dev& print_settings) override; | |
| 86 pp::Resource PrintPages( | |
| 87 const PP_PrintPageNumberRange_Dev* page_ranges, | |
| 88 uint32_t page_range_count) override; | |
| 89 void PrintEnd() override; | |
| 90 bool IsPrintScalingDisabled() override; | |
| 91 | |
| 92 // pp::Private implementation. | |
| 93 virtual pp::Var GetLinkAtPosition(const pp::Point& point); | |
| 94 virtual void GetPrintPresetOptionsFromDocument( | |
| 95 PP_PdfPrintPresetOptions_Dev* options); | |
| 96 | |
| 97 // PPP_Selection_Dev implementation. | |
| 98 pp::Var GetSelectedText(bool html) override; | |
| 99 | |
| 100 // WidgetClient_Dev implementation. | |
| 101 void InvalidateWidget(pp::Widget_Dev widget, | |
| 102 const pp::Rect& dirty_rect) override; | |
| 103 void ScrollbarValueChanged(pp::Scrollbar_Dev scrollbar, | |
| 104 uint32_t value) override; | |
| 105 void ScrollbarOverlayChanged(pp::Scrollbar_Dev scrollbar, | |
| 106 bool overlay) override; | |
| 107 | |
| 108 // pp::Zoom_Dev implementation. | |
| 109 void Zoom(double scale, bool text_only) override; | |
| 110 void ZoomChanged(double factor); // Override. | |
| 111 | |
| 112 void FlushCallback(int32_t result); | |
| 113 void DidOpen(int32_t result); | |
| 114 void DidOpenPreview(int32_t result); | |
| 115 // If the given widget intersects the rectangle, paints it and adds the | |
| 116 // rect to ready. | |
| 117 void PaintIfWidgetIntersects(pp::Widget_Dev* widget, | |
| 118 const pp::Rect& rect, | |
| 119 std::vector<PaintManager::ReadyRect>* ready, | |
| 120 std::vector<pp::Rect>* pending); | |
| 121 | |
| 122 // Called when the timer is fired. | |
| 123 void OnTimerFired(int32_t); | |
| 124 void OnClientTimerFired(int32_t id); | |
| 125 | |
| 126 // Called when the control timer is fired. | |
| 127 void OnControlTimerFired(int32_t, | |
| 128 const uint32& control_id, | |
| 129 const uint32& timer_id); | |
| 130 | |
| 131 // Called to print without re-entrancy issues. | |
| 132 void OnPrint(int32_t); | |
| 133 | |
| 134 // PDFEngine::Client implementation. | |
| 135 void DocumentSizeUpdated(const pp::Size& size) override; | |
| 136 void Invalidate(const pp::Rect& rect) override; | |
| 137 void Scroll(const pp::Point& point) override; | |
| 138 void ScrollToX(int position) override; | |
| 139 void ScrollToY(int position) override; | |
| 140 void ScrollToPage(int page) override; | |
| 141 void NavigateTo(const std::string& url, bool open_in_new_tab) override; | |
| 142 void UpdateCursor(PP_CursorType_Dev cursor) override; | |
| 143 void UpdateTickMarks(const std::vector<pp::Rect>& tickmarks) override; | |
| 144 void NotifyNumberOfFindResultsChanged(int total, bool final_result) override; | |
| 145 void NotifySelectedFindResultChanged(int current_find_index) override; | |
| 146 void GetDocumentPassword( | |
| 147 pp::CompletionCallbackWithOutput<pp::Var> callback) override; | |
| 148 void Alert(const std::string& message) override; | |
| 149 bool Confirm(const std::string& message) override; | |
| 150 std::string Prompt(const std::string& question, | |
| 151 const std::string& default_answer) override; | |
| 152 std::string GetURL() override; | |
| 153 void Email(const std::string& to, | |
| 154 const std::string& cc, | |
| 155 const std::string& bcc, | |
| 156 const std::string& subject, | |
| 157 const std::string& body) override; | |
| 158 void Print() override; | |
| 159 void SubmitForm(const std::string& url, | |
| 160 const void* data, | |
| 161 int length) override; | |
| 162 std::string ShowFileSelectionDialog(); | |
| 163 pp::URLLoader CreateURLLoader() override; | |
| 164 void ScheduleCallback(int id, int delay_in_ms) override; | |
| 165 void SearchString(const base::char16* string, | |
| 166 const base::char16* term, | |
| 167 bool case_sensitive, | |
| 168 std::vector<SearchStringResult>* results) override; | |
| 169 void DocumentPaintOccurred() override; | |
| 170 void DocumentLoadComplete(int page_count) override; | |
| 171 void DocumentLoadFailed() override; | |
| 172 pp::Instance* GetPluginInstance() override; | |
| 173 void DocumentHasUnsupportedFeature(const std::string& feature) override; | |
| 174 void DocumentLoadProgress(uint32 available, uint32 doc_size) override; | |
| 175 void FormTextFieldFocusChange(bool in_focus) override; | |
| 176 bool IsPrintPreview() override; | |
| 177 uint32 GetBackgroundColor() override; | |
| 178 | |
| 179 // ControlOwner implementation. | |
| 180 void OnEvent(uint32 control_id, uint32 event_id, void* data) override; | |
| 181 void Invalidate(uint32 control_id, const pp::Rect& rc) override; | |
| 182 uint32 ScheduleTimer(uint32 control_id, uint32 timeout_ms) override; | |
| 183 void SetEventCapture(uint32 control_id, bool set_capture) override; | |
| 184 void SetCursor(uint32 control_id, PP_CursorType_Dev cursor_type) override; | |
| 185 pp::Instance* GetInstance() override; | |
| 186 | |
| 187 bool dont_paint() const { return dont_paint_; } | |
| 188 void set_dont_paint(bool dont_paint) { dont_paint_ = dont_paint; } | |
| 189 | |
| 190 // Called by PDFScriptableObject. | |
| 191 bool HasScriptableMethod(const pp::Var& method, pp::Var* exception); | |
| 192 pp::Var CallScriptableMethod(const pp::Var& method, | |
| 193 const std::vector<pp::Var>& args, | |
| 194 pp::Var* exception); | |
| 195 | |
| 196 // PreviewModeClient::Client implementation. | |
| 197 void PreviewDocumentLoadComplete() override; | |
| 198 void PreviewDocumentLoadFailed() override; | |
| 199 | |
| 200 // Helper functions for implementing PPP_PDF. | |
| 201 void RotateClockwise(); | |
| 202 void RotateCounterclockwise(); | |
| 203 | |
| 204 // Helper function to inform when mouse pointer is on scrollbar, returns true | |
| 205 // when mouse is on vertical or horizaontal scrollbar else returns false. | |
| 206 bool IsMouseOnScrollbar(const pp::InputEvent& event); | |
| 207 | |
| 208 private: | |
| 209 // Called whenever the plugin geometry changes to update the location of the | |
| 210 // scrollbars, background parts, and notifies the pdf engine. | |
| 211 void OnGeometryChanged(double old_zoom, float old_device_scale); | |
| 212 | |
| 213 // Runs the given JS callback given in |callback|. | |
| 214 void RunCallback(int32_t, pp::Var callback); | |
| 215 | |
| 216 void CreateHorizontalScrollbar(); | |
| 217 void CreateVerticalScrollbar(); | |
| 218 void DestroyHorizontalScrollbar(); | |
| 219 void DestroyVerticalScrollbar(); | |
| 220 | |
| 221 // Returns the thickness of a scrollbar. This returns the thickness when it's | |
| 222 // shown, so for overlay scrollbars it'll still be non-zero. | |
| 223 int GetScrollbarThickness(); | |
| 224 | |
| 225 // Returns the space we need to reserve for the scrollbar in the plugin area. | |
| 226 // If overlay scrollbars are used, this will be 0. | |
| 227 int GetScrollbarReservedThickness(); | |
| 228 | |
| 229 // Returns true if overlay scrollbars are in use. | |
| 230 bool IsOverlayScrollbar(); | |
| 231 | |
| 232 // Figures out the location of any background rectangles (i.e. those that | |
| 233 // aren't painted by the PDF engine). | |
| 234 void CalculateBackgroundParts(); | |
| 235 | |
| 236 // Computes document width/height in device pixels, based on current zoom and | |
| 237 // device scale | |
| 238 int GetDocumentPixelWidth() const; | |
| 239 int GetDocumentPixelHeight() const; | |
| 240 | |
| 241 // Draws a rectangle with the specified dimensions and color in our buffer. | |
| 242 void FillRect(const pp::Rect& rect, uint32 color); | |
| 243 | |
| 244 std::vector<pp::ImageData> GetThumbnailResources(); | |
| 245 std::vector<pp::ImageData> GetProgressBarResources(pp::ImageData* background); | |
| 246 | |
| 247 void CreateToolbar(const ToolbarButtonInfo* tb_info, size_t size); | |
| 248 int GetToolbarRightOffset(); | |
| 249 int GetToolbarBottomOffset(); | |
| 250 void CreateProgressBar(); | |
| 251 void ConfigureProgressBar(); | |
| 252 void CreateThumbnails(); | |
| 253 void CreatePageIndicator(bool always_visible); | |
| 254 void ConfigurePageIndicator(); | |
| 255 | |
| 256 void PaintOverlayControl(Control* ctrl, | |
| 257 pp::ImageData* image_data, | |
| 258 std::vector<PaintManager::ReadyRect>* ready); | |
| 259 | |
| 260 void LoadUrl(const std::string& url); | |
| 261 void LoadPreviewUrl(const std::string& url); | |
| 262 void LoadUrlInternal(const std::string& url, pp::URLLoader* loader, | |
| 263 void (Instance::* method)(int32_t)); | |
| 264 | |
| 265 // Creates a URL loader and allows it to access all urls, i.e. not just the | |
| 266 // frame's origin. | |
| 267 pp::URLLoader CreateURLLoaderInternal(); | |
| 268 | |
| 269 // Figure out the initial page to display based on #page=N and #nameddest=foo | |
| 270 // in the |url_|. | |
| 271 // Returns -1 if there is no valid fragment. The returned value is 0-based, | |
| 272 // whereas page=N is 1-based. | |
| 273 int GetInitialPage(const std::string& url); | |
| 274 | |
| 275 void UpdateToolbarPosition(bool invalidate); | |
| 276 void UpdateProgressBarPosition(bool invalidate); | |
| 277 void UpdatePageIndicatorPosition(bool invalidate); | |
| 278 | |
| 279 void FormDidOpen(int32_t result); | |
| 280 | |
| 281 std::string GetLocalizedString(PP_ResourceString id); | |
| 282 | |
| 283 void UserMetricsRecordAction(const std::string& action); | |
| 284 | |
| 285 void SaveAs(); | |
| 286 | |
| 287 enum ZoomMode { | |
| 288 ZOOM_SCALE, // Standard zooming mode, resize will not affect it. | |
| 289 ZOOM_FIT_TO_WIDTH, // Maintain fit to width on resize. | |
| 290 ZOOM_FIT_TO_PAGE, // Maintain fit to page on resize. | |
| 291 ZOOM_AUTO // Maintain the default auto fitting mode on resize. | |
| 292 }; | |
| 293 | |
| 294 enum DocumentLoadState { | |
| 295 LOAD_STATE_LOADING, | |
| 296 LOAD_STATE_COMPLETE, | |
| 297 LOAD_STATE_FAILED, | |
| 298 }; | |
| 299 | |
| 300 // Set new zoom mode and scale. Scale will be ignored if mode != ZOOM_SCALE. | |
| 301 void SetZoom(ZoomMode zoom_mode, double scale); | |
| 302 | |
| 303 // Updates internal zoom scale based on the plugin/document geometry and | |
| 304 // current mode. | |
| 305 void UpdateZoomScale(); | |
| 306 | |
| 307 // Simulates how Chrome "snaps" zooming up/down to the next nearest zoom level | |
| 308 // when the previous zoom level wasn't an integer. We do this so that | |
| 309 // pressing the zoom buttons has the same effect as the menu buttons, even if | |
| 310 // we start from a non-standard zoom level because of fit-width or fit-height. | |
| 311 double CalculateZoom(uint32 control_id) const; | |
| 312 | |
| 313 pp::ImageData CreateResourceImage(PP_ResourceImage image_id); | |
| 314 | |
| 315 void DrawText(const pp::Point& top_center, PP_ResourceString id); | |
| 316 | |
| 317 // Set print preview mode, where the current PDF document is reduced to | |
| 318 // only one page, and then extended to |page_count| pages with | |
| 319 // |page_count| - 1 blank pages. | |
| 320 void SetPrintPreviewMode(int page_count); | |
| 321 | |
| 322 // Returns the page number to be displayed in the page indicator. If the | |
| 323 // plugin is running within print preview, the displayed number might be | |
| 324 // different from the index of the displayed page. | |
| 325 int GetPageNumberToDisplay(); | |
| 326 | |
| 327 // Process the preview page data information. |src_url| specifies the preview | |
| 328 // page data location. The |src_url| is in the format: | |
| 329 // chrome://print/id/page_number/print.pdf | |
| 330 // |dst_page_index| specifies the blank page index that needs to be replaced | |
| 331 // with the new page data. | |
| 332 void ProcessPreviewPageInfo(const std::string& src_url, int dst_page_index); | |
| 333 // Load the next available preview page into the blank page. | |
| 334 void LoadAvailablePreviewPage(); | |
| 335 | |
| 336 // Enables autoscroll using origin as a neutral (center) point. | |
| 337 void EnableAutoscroll(const pp::Point& origin); | |
| 338 // Disables autoscroll and returns to normal functionality. | |
| 339 void DisableAutoscroll(); | |
| 340 // Calculate autoscroll info and return proper mouse pointer and scroll | |
| 341 // andjustments. | |
| 342 PP_CursorType_Dev CalculateAutoscroll(const pp::Point& mouse_pos); | |
| 343 | |
| 344 void ConfigureNumberImageGenerator(); | |
| 345 | |
| 346 NumberImageGenerator* number_image_generator(); | |
| 347 | |
| 348 int GetScaled(int x) const; | |
| 349 | |
| 350 pp::ImageData image_data_; | |
| 351 // Used when the plugin is embedded in a page and we have to create the loader | |
| 352 // ourself. | |
| 353 pp::CompletionCallbackFactory<Instance> loader_factory_; | |
| 354 pp::URLLoader embed_loader_; | |
| 355 pp::URLLoader embed_preview_loader_; | |
| 356 | |
| 357 scoped_ptr<pp::Scrollbar_Dev> h_scrollbar_; | |
| 358 scoped_ptr<pp::Scrollbar_Dev> v_scrollbar_; | |
| 359 int32 valid_v_range_; | |
| 360 | |
| 361 PP_CursorType_Dev cursor_; // The current cursor. | |
| 362 | |
| 363 // Used when selecting and dragging beyond the visible portion, in which case | |
| 364 // we want to scroll the document. | |
| 365 bool timer_pending_; | |
| 366 pp::MouseInputEvent last_mouse_event_; | |
| 367 pp::CompletionCallbackFactory<Instance> timer_factory_; | |
| 368 uint32 current_timer_id_; | |
| 369 | |
| 370 // Size, in pixels, of plugin rectangle. | |
| 371 pp::Size plugin_size_; | |
| 372 // Size, in DIPs, of plugin rectangle. | |
| 373 pp::Size plugin_dip_size_; | |
| 374 // Remaining area, in pixels, to render the pdf in after accounting for | |
| 375 // scrollbars/toolbars and horizontal centering. | |
| 376 pp::Rect available_area_; | |
| 377 // Size of entire document in pixels (i.e. if each page is 800 pixels high and | |
| 378 // there are 10 pages, the height will be 8000). | |
| 379 pp::Size document_size_; | |
| 380 | |
| 381 double zoom_; // Current zoom factor. | |
| 382 | |
| 383 float device_scale_; // Current device scale factor. | |
| 384 bool printing_enabled_; | |
| 385 bool hidpi_enabled_; | |
| 386 // True if the plugin is full-page. | |
| 387 bool full_; | |
| 388 // Zooming mode (none, fit to width, fit to height) | |
| 389 ZoomMode zoom_mode_; | |
| 390 | |
| 391 // If true, this means we told the RenderView that we're starting a network | |
| 392 // request so that it can start the throbber. We will tell it again once the | |
| 393 // document finishes loading. | |
| 394 bool did_call_start_loading_; | |
| 395 | |
| 396 // Hold off on painting invalidated requests while this flag is true. | |
| 397 bool dont_paint_; | |
| 398 | |
| 399 // Indicates if plugin is in autoscroll mode. | |
| 400 bool is_autoscroll_; | |
| 401 // Rect for autoscroll anchor. | |
| 402 pp::Rect autoscroll_rect_; | |
| 403 // Image of the autoscroll anchor and its background. | |
| 404 pp::ImageData autoscroll_anchor_; | |
| 405 // Autoscrolling deltas in pixels. | |
| 406 int autoscroll_x_; | |
| 407 int autoscroll_y_; | |
| 408 | |
| 409 // Thickness of a scrollbar. | |
| 410 int scrollbar_thickness_; | |
| 411 | |
| 412 // Reserved thickness of a scrollbar. This is how much space the scrollbar | |
| 413 // takes from the available area. 0 for overlay. | |
| 414 int scrollbar_reserved_thickness_; | |
| 415 | |
| 416 // Used to remember which toolbar is in use | |
| 417 const ToolbarButtonInfo* current_tb_info_; | |
| 418 size_t current_tb_info_size_; | |
| 419 | |
| 420 PaintManager paint_manager_; | |
| 421 | |
| 422 struct BackgroundPart { | |
| 423 pp::Rect location; | |
| 424 uint32 color; | |
| 425 }; | |
| 426 std::vector<BackgroundPart> background_parts_; | |
| 427 | |
| 428 struct PrintSettings { | |
| 429 PrintSettings() { | |
| 430 Clear(); | |
| 431 } | |
| 432 void Clear() { | |
| 433 is_printing = false; | |
| 434 print_pages_called_ = false; | |
| 435 memset(&pepper_print_settings, 0, sizeof(pepper_print_settings)); | |
| 436 } | |
| 437 // This is set to true when PrintBegin is called and false when PrintEnd is | |
| 438 // called. | |
| 439 bool is_printing; | |
| 440 // To know whether this was an actual print operation, so we don't double | |
| 441 // count UMA logging. | |
| 442 bool print_pages_called_; | |
| 443 PP_PrintSettings_Dev pepper_print_settings; | |
| 444 }; | |
| 445 | |
| 446 PrintSettings print_settings_; | |
| 447 | |
| 448 scoped_ptr<PDFEngine> engine_; | |
| 449 | |
| 450 // This engine is used to render the individual preview page data. This is | |
| 451 // used only in print preview mode. This will use |PreviewModeClient| | |
| 452 // interface which has very limited access to the pp::Instance. | |
| 453 scoped_ptr<PDFEngine> preview_engine_; | |
| 454 | |
| 455 std::string url_; | |
| 456 | |
| 457 scoped_ptr<FadingControls> toolbar_; | |
| 458 ThumbnailControl thumbnails_; | |
| 459 ProgressControl progress_bar_; | |
| 460 uint32 delayed_progress_timer_id_; | |
| 461 PageIndicator page_indicator_; | |
| 462 | |
| 463 // Used for creating images from numbers. | |
| 464 scoped_ptr<NumberImageGenerator> number_image_generator_; | |
| 465 | |
| 466 // Used for submitting forms. | |
| 467 pp::CompletionCallbackFactory<Instance> form_factory_; | |
| 468 pp::URLLoader form_loader_; | |
| 469 | |
| 470 // Used for generating callbacks. | |
| 471 // TODO(raymes): We don't really need other callback factories we can just | |
| 472 // fold them into this one. | |
| 473 pp::CompletionCallbackFactory<Instance> callback_factory_; | |
| 474 | |
| 475 // True if we haven't painted the plugin viewport yet. | |
| 476 bool first_paint_; | |
| 477 | |
| 478 // True when we've painted at least one page from the document. | |
| 479 bool painted_first_page_; | |
| 480 | |
| 481 // True if we should display page indicator, false otherwise | |
| 482 bool show_page_indicator_; | |
| 483 | |
| 484 // Callback when the document load completes. | |
| 485 pp::Var on_load_callback_; | |
| 486 pp::Var on_scroll_callback_; | |
| 487 pp::Var on_plugin_size_changed_callback_; | |
| 488 | |
| 489 DocumentLoadState document_load_state_; | |
| 490 DocumentLoadState preview_document_load_state_; | |
| 491 | |
| 492 // JavaScript interface to control this instance. | |
| 493 // This wraps a PDFScriptableObject in a pp::Var. | |
| 494 pp::VarPrivate instance_object_; | |
| 495 | |
| 496 // Used so that we only tell the browser once about an unsupported feature, to | |
| 497 // avoid the infobar going up more than once. | |
| 498 bool told_browser_about_unsupported_feature_; | |
| 499 | |
| 500 // Keeps track of which unsupported features we reported, so we avoid spamming | |
| 501 // the stats if a feature shows up many times per document. | |
| 502 std::set<std::string> unsupported_features_reported_; | |
| 503 | |
| 504 // Number of pages in print preview mode, 0 if not in print preview mode. | |
| 505 int print_preview_page_count_; | |
| 506 std::vector<int> print_preview_page_numbers_; | |
| 507 | |
| 508 // Used to manage loaded print preview page information. A |PreviewPageInfo| | |
| 509 // consists of data source url string and the page index in the destination | |
| 510 // document. | |
| 511 typedef std::pair<std::string, int> PreviewPageInfo; | |
| 512 std::queue<PreviewPageInfo> preview_pages_info_; | |
| 513 | |
| 514 // Used to signal the browser about focus changes to trigger the OSK. | |
| 515 // TODO(abodenha@chromium.org) Implement full IME support in the plugin. | |
| 516 // http://crbug.com/132565 | |
| 517 scoped_ptr<pp::TextInput_Dev> text_input_; | |
| 518 }; | |
| 519 | |
| 520 // This implements the JavaScript class entrypoint for the plugin instance. | |
| 521 // This class is just a thin wrapper. It delegates relevant methods to Instance. | |
| 522 class PDFScriptableObject : public pp::deprecated::ScriptableObject { | |
| 523 public: | |
| 524 explicit PDFScriptableObject(Instance* instance); | |
| 525 virtual ~PDFScriptableObject(); | |
| 526 | |
| 527 // pp::deprecated::ScriptableObject implementation. | |
| 528 virtual bool HasMethod(const pp::Var& method, pp::Var* exception); | |
| 529 virtual pp::Var Call(const pp::Var& method, | |
| 530 const std::vector<pp::Var>& args, | |
| 531 pp::Var* exception); | |
| 532 | |
| 533 private: | |
| 534 Instance* instance_; | |
| 535 }; | |
| 536 | |
| 537 } // namespace chrome_pdf | |
| 538 | |
| 539 #endif // PDF_INSTANCE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1125103002:
Remove the in-process PDF viewer from pdf/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@remove-in-process-instance