Merge XFA to PDFium master at 4dc95e7 on 10/28/2014
[pdfium.git] / xfa_test / pdf / out_of_process_instance.cc
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 #include "pdf/out_of_process_instance.h"
6
7 #include <algorithm>  // for min/max()
8 #define _USE_MATH_DEFINES  // for M_PI
9 #include <cmath>      // for log() and pow()
10 #include <math.h>
11 #include <list>
12
13 #include "base/json/json_reader.h"
14 #include "base/json/json_writer.h"
15 #include "base/logging.h"
16 #include "base/strings/string_number_conversions.h"
17 #include "base/strings/string_split.h"
18 #include "base/strings/string_util.h"
19 #include "base/values.h"
20 #include "chrome/common/content_restriction.h"
21 #include "net/base/escape.h"
22 #include "pdf/pdf.h"
23 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
24 #include "ppapi/c/pp_errors.h"
25 #include "ppapi/c/pp_rect.h"
26 #include "ppapi/c/private/ppb_instance_private.h"
27 #include "ppapi/c/private/ppp_pdf.h"
28 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
29 #include "ppapi/cpp/core.h"
30 #include "ppapi/cpp/dev/memory_dev.h"
31 #include "ppapi/cpp/dev/text_input_dev.h"
32 #include "ppapi/cpp/dev/url_util_dev.h"
33 #include "ppapi/cpp/module.h"
34 #include "ppapi/cpp/point.h"
35 #include "ppapi/cpp/private/pdf.h"
36 #include "ppapi/cpp/private/var_private.h"
37 #include "ppapi/cpp/rect.h"
38 #include "ppapi/cpp/resource.h"
39 #include "ppapi/cpp/url_request_info.h"
40 #include "ppapi/cpp/var_array.h"
41 #include "ppapi/cpp/var_dictionary.h"
42 #include "ui/events/keycodes/keyboard_codes.h"
43
44 #if defined(OS_MACOSX)
45 #include "base/mac/mac_util.h"
46 #endif
47
48 namespace chrome_pdf {
49
50 const char kChromePrint[] = "chrome://print/";
51 const char kChromeExtension[] =
52     "chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai";
53
54 // Dictionary Value key names for the document accessibility info
55 const char kAccessibleNumberOfPages[] = "numberOfPages";
56 const char kAccessibleLoaded[] = "loaded";
57 const char kAccessibleCopyable[] = "copyable";
58
59 // Constants used in handling postMessage() messages.
60 const char kType[] = "type";
61 // Viewport message arguments. (Page -> Plugin).
62 const char kJSViewportType[] = "viewport";
63 const char kJSXOffset[] = "xOffset";
64 const char kJSYOffset[] = "yOffset";
65 const char kJSZoom[] = "zoom";
66 // Stop scrolling message (Page -> Plugin)
67 const char kJSStopScrollingType[] = "stopScrolling";
68 // Document dimension arguments (Plugin -> Page).
69 const char kJSDocumentDimensionsType[] = "documentDimensions";
70 const char kJSDocumentWidth[] = "width";
71 const char kJSDocumentHeight[] = "height";
72 const char kJSPageDimensions[] = "pageDimensions";
73 const char kJSPageX[] = "x";
74 const char kJSPageY[] = "y";
75 const char kJSPageWidth[] = "width";
76 const char kJSPageHeight[] = "height";
77 // Document load progress arguments (Plugin -> Page)
78 const char kJSLoadProgressType[] = "loadProgress";
79 const char kJSProgressPercentage[] = "progress";
80 // Get password arguments (Plugin -> Page)
81 const char kJSGetPasswordType[] = "getPassword";
82 // Get password complete arguments (Page -> Plugin)
83 const char kJSGetPasswordCompleteType[] = "getPasswordComplete";
84 const char kJSPassword[] = "password";
85 // Print (Page -> Plugin)
86 const char kJSPrintType[] = "print";
87 // Go to page (Plugin -> Page)
88 const char kJSGoToPageType[] = "goToPage";
89 const char kJSPageNumber[] = "page";
90 // Reset print preview mode (Page -> Plugin)
91 const char kJSResetPrintPreviewModeType[] = "resetPrintPreviewMode";
92 const char kJSPrintPreviewUrl[] = "url";
93 const char kJSPrintPreviewGrayscale[] = "grayscale";
94 const char kJSPrintPreviewPageCount[] = "pageCount";
95 // Load preview page (Page -> Plugin)
96 const char kJSLoadPreviewPageType[] = "loadPreviewPage";
97 const char kJSPreviewPageUrl[] = "url";
98 const char kJSPreviewPageIndex[] = "index";
99 // Set scroll position (Plugin -> Page)
100 const char kJSSetScrollPositionType[] = "setScrollPosition";
101 const char kJSPositionX[] = "x";
102 const char kJSPositionY[] = "y";
103 // Set translated strings (Plugin -> Page)
104 const char kJSSetTranslatedStringsType[] = "setTranslatedStrings";
105 const char kJSGetPasswordString[] = "getPasswordString";
106 const char kJSLoadingString[] = "loadingString";
107 const char kJSLoadFailedString[] = "loadFailedString";
108 // Request accessibility JSON data (Page -> Plugin)
109 const char kJSGetAccessibilityJSONType[] = "getAccessibilityJSON";
110 const char kJSAccessibilityPageNumber[] = "page";
111 // Reply with accessibility JSON data (Plugin -> Page)
112 const char kJSGetAccessibilityJSONReplyType[] = "getAccessibilityJSONReply";
113 const char kJSAccessibilityJSON[] = "json";
114 // Cancel the stream URL request (Plugin -> Page)
115 const char kJSCancelStreamUrlType[] = "cancelStreamUrl";
116 // Navigate to the given URL (Plugin -> Page)
117 const char kJSNavigateType[] = "navigate";
118 const char kJSNavigateUrl[] = "url";
119 const char kJSNavigateNewTab[] = "newTab";
120 // Open the email editor with the given parameters (Plugin -> Page)
121 const char kJSEmailType[] = "email";
122 const char kJSEmailTo[] = "to";
123 const char kJSEmailCc[] = "cc";
124 const char kJSEmailBcc[] = "bcc";
125 const char kJSEmailSubject[] = "subject";
126 const char kJSEmailBody[] = "body";
127 // Rotation (Page -> Plugin)
128 const char kJSRotateClockwiseType[] = "rotateClockwise";
129 const char kJSRotateCounterclockwiseType[] = "rotateCounterclockwise";
130 // Select all text in the document (Page -> Plugin)
131 const char kJSSelectAllType[] = "selectAll";
132
133 const int kFindResultCooldownMs = 100;
134
135 const double kMinZoom = 0.01;
136
137 namespace {
138
139 static const char kPPPPdfInterface[] = PPP_PDF_INTERFACE_1;
140
141 PP_Var GetLinkAtPosition(PP_Instance instance, PP_Point point) {
142   pp::Var var;
143   void* object = pp::Instance::GetPerInstanceObject(instance, kPPPPdfInterface);
144   if (object) {
145     var = static_cast<OutOfProcessInstance*>(object)->GetLinkAtPosition(
146         pp::Point(point));
147   }
148   return var.Detach();
149 }
150
151 void Transform(PP_Instance instance, PP_PrivatePageTransformType type) {
152   void* object =
153       pp::Instance::GetPerInstanceObject(instance, kPPPPdfInterface);
154   if (object) {
155     OutOfProcessInstance* obj_instance =
156         static_cast<OutOfProcessInstance*>(object);
157     switch (type) {
158       case PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CW:
159         obj_instance->RotateClockwise();
160         break;
161       case PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CCW:
162         obj_instance->RotateCounterclockwise();
163         break;
164     }
165   }
166 }
167
168 const PPP_Pdf ppp_private = {
169   &GetLinkAtPosition,
170   &Transform
171 };
172
173 int ExtractPrintPreviewPageIndex(const std::string& src_url) {
174   // Sample |src_url| format: chrome://print/id/page_index/print.pdf
175   std::vector<std::string> url_substr;
176   base::SplitString(src_url.substr(strlen(kChromePrint)), '/', &url_substr);
177   if (url_substr.size() != 3)
178     return -1;
179
180   if (url_substr[2] != "print.pdf")
181     return -1;
182
183   int page_index = 0;
184   if (!base::StringToInt(url_substr[1], &page_index))
185     return -1;
186   return page_index;
187 }
188
189 bool IsPrintPreviewUrl(const std::string& url) {
190   return url.substr(0, strlen(kChromePrint)) == kChromePrint;
191 }
192
193 void ScalePoint(float scale, pp::Point* point) {
194   point->set_x(static_cast<int>(point->x() * scale));
195   point->set_y(static_cast<int>(point->y() * scale));
196 }
197
198 void ScaleRect(float scale, pp::Rect* rect) {
199   int left = static_cast<int>(floorf(rect->x() * scale));
200   int top = static_cast<int>(floorf(rect->y() * scale));
201   int right = static_cast<int>(ceilf((rect->x() + rect->width()) * scale));
202   int bottom = static_cast<int>(ceilf((rect->y() + rect->height()) * scale));
203   rect->SetRect(left, top, right - left, bottom - top);
204 }
205
206 // TODO(raymes): Remove this dependency on VarPrivate/InstancePrivate. It's
207 // needed right now to do a synchronous call to JavaScript, but we could easily
208 // replace this with a custom PPB_PDF function.
209 pp::Var ModalDialog(const pp::Instance* instance,
210                     const std::string& type,
211                     const std::string& message,
212                     const std::string& default_answer) {
213   const PPB_Instance_Private* interface =
214       reinterpret_cast<const PPB_Instance_Private*>(
215           pp::Module::Get()->GetBrowserInterface(
216               PPB_INSTANCE_PRIVATE_INTERFACE));
217   pp::VarPrivate window(pp::PASS_REF,
218       interface->GetWindowObject(instance->pp_instance()));
219   if (default_answer.empty())
220     return window.Call(type, message);
221   else
222     return window.Call(type, message, default_answer);
223 }
224
225 }  // namespace
226
227 OutOfProcessInstance::OutOfProcessInstance(PP_Instance instance)
228     : pp::Instance(instance),
229       pp::Find_Private(this),
230       pp::Printing_Dev(this),
231       pp::Selection_Dev(this),
232       cursor_(PP_CURSORTYPE_POINTER),
233       zoom_(1.0),
234       device_scale_(1.0),
235       printing_enabled_(true),
236       full_(false),
237       paint_manager_(this, this, true),
238       first_paint_(true),
239       document_load_state_(LOAD_STATE_LOADING),
240       preview_document_load_state_(LOAD_STATE_COMPLETE),
241       uma_(this),
242       told_browser_about_unsupported_feature_(false),
243       print_preview_page_count_(0),
244       last_progress_sent_(0),
245       recently_sent_find_update_(false),
246       received_viewport_message_(false),
247       did_call_start_loading_(false),
248       stop_scrolling_(false) {
249   loader_factory_.Initialize(this);
250   timer_factory_.Initialize(this);
251   form_factory_.Initialize(this);
252   print_callback_factory_.Initialize(this);
253   engine_.reset(PDFEngine::Create(this));
254   pp::Module::Get()->AddPluginInterface(kPPPPdfInterface, &ppp_private);
255   AddPerInstanceObject(kPPPPdfInterface, this);
256
257   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
258   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
259   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_TOUCH);
260 }
261
262 OutOfProcessInstance::~OutOfProcessInstance() {
263   RemovePerInstanceObject(kPPPPdfInterface, this);
264 }
265
266 bool OutOfProcessInstance::Init(uint32_t argc,
267                                 const char* argn[],
268                                 const char* argv[]) {
269   // Check if the PDF is being loaded in the PDF chrome extension. We only allow
270   // the plugin to be put into "full frame" mode when it is being loaded in the
271   // extension because this enables some features that we don't want pages
272   // abusing outside of the extension.
273   pp::Var document_url_var = pp::URLUtil_Dev::Get()->GetDocumentURL(this);
274   std::string document_url = document_url_var.is_string() ?
275       document_url_var.AsString() : std::string();
276   std::string extension_url = std::string(kChromeExtension);
277   bool in_extension =
278       !document_url.compare(0, extension_url.size(), extension_url);
279
280   if (in_extension) {
281     // Check if the plugin is full frame. This is passed in from JS.
282     for (uint32_t i = 0; i < argc; ++i) {
283       if (strcmp(argn[i], "full-frame") == 0) {
284         full_ = true;
285         break;
286       }
287     }
288   }
289
290   // Only allow the plugin to handle find requests if it is full frame.
291   if (full_)
292     SetPluginToHandleFindRequests();
293
294   // Send translated strings to the extension where they will be displayed.
295   // TODO(raymes): It would be better to get these in the extension directly
296   // through an API but no such API currently exists.
297   pp::VarDictionary translated_strings;
298   translated_strings.Set(kType, kJSSetTranslatedStringsType);
299   translated_strings.Set(kJSGetPasswordString,
300       GetLocalizedString(PP_RESOURCESTRING_PDFGETPASSWORD));
301   translated_strings.Set(kJSLoadingString,
302       GetLocalizedString(PP_RESOURCESTRING_PDFLOADING));
303   translated_strings.Set(kJSLoadFailedString,
304       GetLocalizedString(PP_RESOURCESTRING_PDFLOAD_FAILED));
305   PostMessage(translated_strings);
306
307   text_input_.reset(new pp::TextInput_Dev(this));
308
309   const char* stream_url = NULL;
310   const char* original_url = NULL;
311   const char* headers = NULL;
312   for (uint32_t i = 0; i < argc; ++i) {
313     if (strcmp(argn[i], "src") == 0)
314       original_url = argv[i];
315     else if (strcmp(argn[i], "stream-url") == 0)
316       stream_url = argv[i];
317     else if (strcmp(argn[i], "headers") == 0)
318       headers = argv[i];
319   }
320
321   // TODO(raymes): This is a hack to ensure that if no headers are passed in
322   // then we get the right MIME type. When the in process plugin is removed we
323   // can fix the document loader properly and remove this hack.
324   if (!headers || strcmp(headers, "") == 0)
325     headers = "content-type: application/pdf";
326
327   if (!original_url)
328     return false;
329
330   if (!stream_url)
331     stream_url = original_url;
332
333   // If we're in print preview mode we don't need to load the document yet.
334   // A |kJSResetPrintPreviewModeType| message will be sent to the plugin letting
335   // it know the url to load. By not loading here we avoid loading the same
336   // document twice.
337   if (IsPrintPreviewUrl(original_url))
338     return true;
339
340   LoadUrl(stream_url);
341   url_ = original_url;
342   return engine_->New(original_url, headers);
343 }
344
345 void OutOfProcessInstance::HandleMessage(const pp::Var& message) {
346   pp::VarDictionary dict(message);
347   if (!dict.Get(kType).is_string()) {
348     NOTREACHED();
349     return;
350   }
351
352   std::string type = dict.Get(kType).AsString();
353
354   if (type == kJSViewportType &&
355       dict.Get(pp::Var(kJSXOffset)).is_int() &&
356       dict.Get(pp::Var(kJSYOffset)).is_int() &&
357       dict.Get(pp::Var(kJSZoom)).is_number()) {
358     received_viewport_message_ = true;
359     stop_scrolling_ = false;
360     double zoom = dict.Get(pp::Var(kJSZoom)).AsDouble();
361     pp::Point scroll_offset(dict.Get(pp::Var(kJSXOffset)).AsInt(),
362                             dict.Get(pp::Var(kJSYOffset)).AsInt());
363
364     // Bound the input parameters.
365     zoom = std::max(kMinZoom, zoom);
366     SetZoom(zoom);
367     scroll_offset = BoundScrollOffsetToDocument(scroll_offset);
368     engine_->ScrolledToXPosition(scroll_offset.x() * device_scale_);
369     engine_->ScrolledToYPosition(scroll_offset.y() * device_scale_);
370   } else if (type == kJSGetPasswordCompleteType &&
371              dict.Get(pp::Var(kJSPassword)).is_string()) {
372     if (password_callback_) {
373       pp::CompletionCallbackWithOutput<pp::Var> callback = *password_callback_;
374       password_callback_.reset();
375       *callback.output() = dict.Get(pp::Var(kJSPassword)).pp_var();
376       callback.Run(PP_OK);
377     } else {
378       NOTREACHED();
379     }
380   } else if (type == kJSPrintType) {
381     Print();
382   } else if (type == kJSRotateClockwiseType) {
383     RotateClockwise();
384   } else if (type == kJSRotateCounterclockwiseType) {
385     RotateCounterclockwise();
386   } else if (type == kJSSelectAllType) {
387     engine_->SelectAll();
388   } else if (type == kJSResetPrintPreviewModeType &&
389              dict.Get(pp::Var(kJSPrintPreviewUrl)).is_string() &&
390              dict.Get(pp::Var(kJSPrintPreviewGrayscale)).is_bool() &&
391              dict.Get(pp::Var(kJSPrintPreviewPageCount)).is_int()) {
392     url_ = dict.Get(pp::Var(kJSPrintPreviewUrl)).AsString();
393     preview_pages_info_ = std::queue<PreviewPageInfo>();
394     preview_document_load_state_ = LOAD_STATE_COMPLETE;
395     document_load_state_ = LOAD_STATE_LOADING;
396     LoadUrl(url_);
397     preview_engine_.reset();
398     engine_.reset(PDFEngine::Create(this));
399     engine_->SetGrayscale(dict.Get(pp::Var(kJSPrintPreviewGrayscale)).AsBool());
400     engine_->New(url_.c_str());
401
402     print_preview_page_count_ =
403         std::max(dict.Get(pp::Var(kJSPrintPreviewPageCount)).AsInt(), 0);
404
405     paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
406   } else if (type == kJSLoadPreviewPageType &&
407              dict.Get(pp::Var(kJSPreviewPageUrl)).is_string() &&
408              dict.Get(pp::Var(kJSPreviewPageIndex)).is_int()) {
409     ProcessPreviewPageInfo(dict.Get(pp::Var(kJSPreviewPageUrl)).AsString(),
410                            dict.Get(pp::Var(kJSPreviewPageIndex)).AsInt());
411   } else if (type == kJSGetAccessibilityJSONType) {
412     pp::VarDictionary reply;
413     reply.Set(pp::Var(kType), pp::Var(kJSGetAccessibilityJSONReplyType));
414     if (dict.Get(pp::Var(kJSAccessibilityPageNumber)).is_int()) {
415       int page = dict.Get(pp::Var(kJSAccessibilityPageNumber)).AsInt();
416       reply.Set(pp::Var(kJSAccessibilityJSON),
417                         pp::Var(engine_->GetPageAsJSON(page)));
418     } else {
419       base::DictionaryValue node;
420       node.SetInteger(kAccessibleNumberOfPages, engine_->GetNumberOfPages());
421       node.SetBoolean(kAccessibleLoaded,
422                       document_load_state_ != LOAD_STATE_LOADING);
423       bool has_permissions =
424           engine_->HasPermission(PDFEngine::PERMISSION_COPY) ||
425           engine_->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE);
426       node.SetBoolean(kAccessibleCopyable, has_permissions);
427       std::string json;
428       base::JSONWriter::Write(&node, &json);
429       reply.Set(pp::Var(kJSAccessibilityJSON), pp::Var(json));
430     }
431     PostMessage(reply);
432   } else if (type == kJSStopScrollingType) {
433     stop_scrolling_ = true;
434   } else {
435     NOTREACHED();
436   }
437 }
438
439 bool OutOfProcessInstance::HandleInputEvent(
440     const pp::InputEvent& event) {
441   // To simplify things, convert the event into device coordinates if it is
442   // a mouse event.
443   pp::InputEvent event_device_res(event);
444   {
445     pp::MouseInputEvent mouse_event(event);
446     if (!mouse_event.is_null()) {
447       pp::Point point = mouse_event.GetPosition();
448       pp::Point movement = mouse_event.GetMovement();
449       ScalePoint(device_scale_, &point);
450       ScalePoint(device_scale_, &movement);
451       mouse_event = pp::MouseInputEvent(
452           this,
453           event.GetType(),
454           event.GetTimeStamp(),
455           event.GetModifiers(),
456           mouse_event.GetButton(),
457           point,
458           mouse_event.GetClickCount(),
459           movement);
460       event_device_res = mouse_event;
461     }
462   }
463
464   pp::InputEvent offset_event(event_device_res);
465   switch (offset_event.GetType()) {
466     case PP_INPUTEVENT_TYPE_MOUSEDOWN:
467     case PP_INPUTEVENT_TYPE_MOUSEUP:
468     case PP_INPUTEVENT_TYPE_MOUSEMOVE:
469     case PP_INPUTEVENT_TYPE_MOUSEENTER:
470     case PP_INPUTEVENT_TYPE_MOUSELEAVE: {
471       pp::MouseInputEvent mouse_event(event_device_res);
472       pp::MouseInputEvent mouse_event_dip(event);
473       pp::Point point = mouse_event.GetPosition();
474       point.set_x(point.x() - available_area_.x());
475       offset_event = pp::MouseInputEvent(
476           this,
477           event.GetType(),
478           event.GetTimeStamp(),
479           event.GetModifiers(),
480           mouse_event.GetButton(),
481           point,
482           mouse_event.GetClickCount(),
483           mouse_event.GetMovement());
484       break;
485     }
486     default:
487       break;
488   }
489   if (engine_->HandleEvent(offset_event))
490     return true;
491
492   // TODO(raymes): Implement this scroll behavior in JS:
493   // When click+dragging, scroll the document correctly.
494
495   // Return true for unhandled clicks so the plugin takes focus.
496   return (event.GetType() == PP_INPUTEVENT_TYPE_MOUSEDOWN);
497 }
498
499 void OutOfProcessInstance::DidChangeView(const pp::View& view) {
500   pp::Rect view_rect(view.GetRect());
501   float old_device_scale = device_scale_;
502   float device_scale = view.GetDeviceScale();
503   pp::Size view_device_size(view_rect.width() * device_scale,
504                             view_rect.height() * device_scale);
505
506   if (view_device_size != plugin_size_ || device_scale != device_scale_) {
507     device_scale_ = device_scale;
508     plugin_dip_size_ = view_rect.size();
509     plugin_size_ = view_device_size;
510
511     paint_manager_.SetSize(view_device_size, device_scale_);
512
513     pp::Size new_image_data_size = PaintManager::GetNewContextSize(
514         image_data_.size(),
515         plugin_size_);
516     if (new_image_data_size != image_data_.size()) {
517       image_data_ = pp::ImageData(this,
518                                   PP_IMAGEDATAFORMAT_BGRA_PREMUL,
519                                   new_image_data_size,
520                                   false);
521       first_paint_ = true;
522     }
523
524     if (image_data_.is_null()) {
525       DCHECK(plugin_size_.IsEmpty());
526       return;
527     }
528
529     OnGeometryChanged(zoom_, old_device_scale);
530   }
531
532   if (!stop_scrolling_) {
533     pp::Point scroll_offset(
534         BoundScrollOffsetToDocument(view.GetScrollOffset()));
535     engine_->ScrolledToXPosition(scroll_offset.x() * device_scale_);
536     engine_->ScrolledToYPosition(scroll_offset.y() * device_scale_);
537   }
538 }
539
540 pp::Var OutOfProcessInstance::GetLinkAtPosition(
541     const pp::Point& point) {
542   pp::Point offset_point(point);
543   ScalePoint(device_scale_, &offset_point);
544   offset_point.set_x(offset_point.x() - available_area_.x());
545   return engine_->GetLinkAtPosition(offset_point);
546 }
547
548 pp::Var OutOfProcessInstance::GetSelectedText(bool html) {
549   if (html || !engine_->HasPermission(PDFEngine::PERMISSION_COPY))
550     return pp::Var();
551   return engine_->GetSelectedText();
552 }
553
554 uint32_t OutOfProcessInstance::QuerySupportedPrintOutputFormats() {
555   return engine_->QuerySupportedPrintOutputFormats();
556 }
557
558 int32_t OutOfProcessInstance::PrintBegin(
559     const PP_PrintSettings_Dev& print_settings) {
560   // For us num_pages is always equal to the number of pages in the PDF
561   // document irrespective of the printable area.
562   int32_t ret = engine_->GetNumberOfPages();
563   if (!ret)
564     return 0;
565
566   uint32_t supported_formats = engine_->QuerySupportedPrintOutputFormats();
567   if ((print_settings.format & supported_formats) == 0)
568     return 0;
569
570   print_settings_.is_printing = true;
571   print_settings_.pepper_print_settings = print_settings;
572   engine_->PrintBegin();
573   return ret;
574 }
575
576 pp::Resource OutOfProcessInstance::PrintPages(
577     const PP_PrintPageNumberRange_Dev* page_ranges,
578     uint32_t page_range_count) {
579   if (!print_settings_.is_printing)
580     return pp::Resource();
581
582   print_settings_.print_pages_called_ = true;
583   return engine_->PrintPages(page_ranges, page_range_count,
584                              print_settings_.pepper_print_settings);
585 }
586
587 void OutOfProcessInstance::PrintEnd() {
588   if (print_settings_.print_pages_called_)
589     UserMetricsRecordAction("PDF.PrintPage");
590   print_settings_.Clear();
591   engine_->PrintEnd();
592 }
593
594 bool OutOfProcessInstance::IsPrintScalingDisabled() {
595   return !engine_->GetPrintScaling();
596 }
597
598 bool OutOfProcessInstance::StartFind(const std::string& text,
599                                                  bool case_sensitive) {
600   engine_->StartFind(text.c_str(), case_sensitive);
601   return true;
602 }
603
604 void OutOfProcessInstance::SelectFindResult(bool forward) {
605   engine_->SelectFindResult(forward);
606 }
607
608 void OutOfProcessInstance::StopFind() {
609   engine_->StopFind();
610   tickmarks_.clear();
611   SetTickmarks(tickmarks_);
612 }
613
614 void OutOfProcessInstance::OnPaint(
615     const std::vector<pp::Rect>& paint_rects,
616     std::vector<PaintManager::ReadyRect>* ready,
617     std::vector<pp::Rect>* pending) {
618   if (image_data_.is_null()) {
619     DCHECK(plugin_size_.IsEmpty());
620     return;
621   }
622   if (first_paint_) {
623     first_paint_ = false;
624     pp::Rect rect = pp::Rect(pp::Point(), image_data_.size());
625     FillRect(rect, kBackgroundColor);
626     ready->push_back(PaintManager::ReadyRect(rect, image_data_, true));
627   }
628
629   if (!received_viewport_message_)
630     return;
631
632   engine_->PrePaint();
633
634   for (size_t i = 0; i < paint_rects.size(); i++) {
635     // Intersect with plugin area since there could be pending invalidates from
636     // when the plugin area was larger.
637     pp::Rect rect =
638         paint_rects[i].Intersect(pp::Rect(pp::Point(), plugin_size_));
639     if (rect.IsEmpty())
640       continue;
641
642     pp::Rect pdf_rect = available_area_.Intersect(rect);
643     if (!pdf_rect.IsEmpty()) {
644       pdf_rect.Offset(available_area_.x() * -1, 0);
645
646       std::vector<pp::Rect> pdf_ready;
647       std::vector<pp::Rect> pdf_pending;
648       engine_->Paint(pdf_rect, &image_data_, &pdf_ready, &pdf_pending);
649       for (size_t j = 0; j < pdf_ready.size(); ++j) {
650         pdf_ready[j].Offset(available_area_.point());
651         ready->push_back(
652             PaintManager::ReadyRect(pdf_ready[j], image_data_, false));
653       }
654       for (size_t j = 0; j < pdf_pending.size(); ++j) {
655         pdf_pending[j].Offset(available_area_.point());
656         pending->push_back(pdf_pending[j]);
657       }
658     }
659
660     for (size_t j = 0; j < background_parts_.size(); ++j) {
661       pp::Rect intersection = background_parts_[j].location.Intersect(rect);
662       if (!intersection.IsEmpty()) {
663         FillRect(intersection, background_parts_[j].color);
664         ready->push_back(
665             PaintManager::ReadyRect(intersection, image_data_, false));
666       }
667     }
668   }
669
670   engine_->PostPaint();
671 }
672
673 void OutOfProcessInstance::DidOpen(int32_t result) {
674   if (result == PP_OK) {
675     if (!engine_->HandleDocumentLoad(embed_loader_)) {
676       document_load_state_ = LOAD_STATE_LOADING;
677       DocumentLoadFailed();
678     }
679   } else if (result != PP_ERROR_ABORTED) {  // Can happen in tests.
680     NOTREACHED();
681     DocumentLoadFailed();
682   }
683
684   // If it's a progressive load, cancel the stream URL request so that requests
685   // can be made on the original URL.
686   // TODO(raymes): Make this clearer once the in-process plugin is deleted.
687   if (engine_->IsProgressiveLoad()) {
688     pp::VarDictionary message;
689     message.Set(kType, kJSCancelStreamUrlType);
690     PostMessage(message);
691   }
692 }
693
694 void OutOfProcessInstance::DidOpenPreview(int32_t result) {
695   if (result == PP_OK) {
696     preview_engine_.reset(PDFEngine::Create(new PreviewModeClient(this)));
697     preview_engine_->HandleDocumentLoad(embed_preview_loader_);
698   } else {
699     NOTREACHED();
700   }
701 }
702
703 void OutOfProcessInstance::OnClientTimerFired(int32_t id) {
704   engine_->OnCallback(id);
705 }
706
707 void OutOfProcessInstance::CalculateBackgroundParts() {
708   background_parts_.clear();
709   int left_width = available_area_.x();
710   int right_start = available_area_.right();
711   int right_width = abs(plugin_size_.width() - available_area_.right());
712   int bottom = std::min(available_area_.bottom(), plugin_size_.height());
713
714   // Add the left, right, and bottom rectangles.  Note: we assume only
715   // horizontal centering.
716   BackgroundPart part = {
717     pp::Rect(0, 0, left_width, bottom),
718     kBackgroundColor
719   };
720   if (!part.location.IsEmpty())
721     background_parts_.push_back(part);
722   part.location = pp::Rect(right_start, 0, right_width, bottom);
723   if (!part.location.IsEmpty())
724     background_parts_.push_back(part);
725   part.location = pp::Rect(
726       0, bottom, plugin_size_.width(), plugin_size_.height() - bottom);
727   if (!part.location.IsEmpty())
728     background_parts_.push_back(part);
729 }
730
731 int OutOfProcessInstance::GetDocumentPixelWidth() const {
732   return static_cast<int>(ceil(document_size_.width() * zoom_ * device_scale_));
733 }
734
735 int OutOfProcessInstance::GetDocumentPixelHeight() const {
736   return static_cast<int>(
737       ceil(document_size_.height() * zoom_ * device_scale_));
738 }
739
740 void OutOfProcessInstance::FillRect(const pp::Rect& rect, uint32 color) {
741   DCHECK(!image_data_.is_null() || rect.IsEmpty());
742   uint32* buffer_start = static_cast<uint32*>(image_data_.data());
743   int stride = image_data_.stride();
744   uint32* ptr = buffer_start + rect.y() * stride / 4 + rect.x();
745   int height = rect.height();
746   int width = rect.width();
747   for (int y = 0; y < height; ++y) {
748     for (int x = 0; x < width; ++x)
749       *(ptr + x) = color;
750     ptr += stride /4;
751   }
752 }
753
754 void OutOfProcessInstance::DocumentSizeUpdated(const pp::Size& size) {
755   document_size_ = size;
756
757   pp::VarDictionary dimensions;
758   dimensions.Set(kType, kJSDocumentDimensionsType);
759   dimensions.Set(kJSDocumentWidth, pp::Var(document_size_.width()));
760   dimensions.Set(kJSDocumentHeight, pp::Var(document_size_.height()));
761   pp::VarArray page_dimensions_array;
762   int num_pages = engine_->GetNumberOfPages();
763   for (int i = 0; i < num_pages; ++i) {
764     pp::Rect page_rect = engine_->GetPageRect(i);
765     pp::VarDictionary page_dimensions;
766     page_dimensions.Set(kJSPageX, pp::Var(page_rect.x()));
767     page_dimensions.Set(kJSPageY, pp::Var(page_rect.y()));
768     page_dimensions.Set(kJSPageWidth, pp::Var(page_rect.width()));
769     page_dimensions.Set(kJSPageHeight, pp::Var(page_rect.height()));
770     page_dimensions_array.Set(i, page_dimensions);
771   }
772   dimensions.Set(kJSPageDimensions, page_dimensions_array);
773   PostMessage(dimensions);
774
775   OnGeometryChanged(zoom_, device_scale_);
776 }
777
778 void OutOfProcessInstance::Invalidate(const pp::Rect& rect) {
779   pp::Rect offset_rect(rect);
780   offset_rect.Offset(available_area_.point());
781   paint_manager_.InvalidateRect(offset_rect);
782 }
783
784 void OutOfProcessInstance::Scroll(const pp::Point& point) {
785   if (!image_data_.is_null())
786     paint_manager_.ScrollRect(available_area_, point);
787 }
788
789 void OutOfProcessInstance::ScrollToX(int x) {
790   pp::VarDictionary position;
791   position.Set(kType, kJSSetScrollPositionType);
792   position.Set(kJSPositionX, pp::Var(x / device_scale_));
793   PostMessage(position);
794 }
795
796 void OutOfProcessInstance::ScrollToY(int y) {
797   pp::VarDictionary position;
798   position.Set(kType, kJSSetScrollPositionType);
799   position.Set(kJSPositionY, pp::Var(y / device_scale_));
800   PostMessage(position);
801 }
802
803 void OutOfProcessInstance::ScrollToPage(int page) {
804   if (engine_->GetNumberOfPages() == 0)
805     return;
806
807   pp::VarDictionary message;
808   message.Set(kType, kJSGoToPageType);
809   message.Set(kJSPageNumber, pp::Var(page));
810   PostMessage(message);
811 }
812
813 void OutOfProcessInstance::NavigateTo(const std::string& url,
814                                       bool open_in_new_tab) {
815   std::string url_copy(url);
816
817   // Empty |url_copy| is ok, and will effectively be a reload.
818   // Skip the code below so an empty URL does not turn into "http://", which
819   // will cause GURL to fail a DCHECK.
820   if (!url_copy.empty()) {
821     // If |url_copy| starts with '#', then it's for the same URL with a
822     // different URL fragment.
823     if (url_copy[0] == '#') {
824       url_copy = url_ + url_copy;
825     }
826     // If there's no scheme, add http.
827     if (url_copy.find("://") == std::string::npos &&
828         url_copy.find("mailto:") == std::string::npos) {
829       url_copy = std::string("http://") + url_copy;
830     }
831     // Make sure |url_copy| starts with a valid scheme.
832     if (url_copy.find("http://") != 0 &&
833         url_copy.find("https://") != 0 &&
834         url_copy.find("ftp://") != 0 &&
835         url_copy.find("file://") != 0 &&
836         url_copy.find("mailto:") != 0) {
837       return;
838     }
839     // Make sure |url_copy| is not only a scheme.
840     if (url_copy == "http://" ||
841         url_copy == "https://" ||
842         url_copy == "ftp://" ||
843         url_copy == "file://" ||
844         url_copy == "mailto:") {
845       return;
846     }
847   }
848   pp::VarDictionary message;
849   message.Set(kType, kJSNavigateType);
850   message.Set(kJSNavigateUrl, url_copy);
851   message.Set(kJSNavigateNewTab, open_in_new_tab);
852   PostMessage(message);
853 }
854
855 void OutOfProcessInstance::UpdateCursor(PP_CursorType_Dev cursor) {
856   if (cursor == cursor_)
857     return;
858   cursor_ = cursor;
859
860   const PPB_CursorControl_Dev* cursor_interface =
861       reinterpret_cast<const PPB_CursorControl_Dev*>(
862       pp::Module::Get()->GetBrowserInterface(PPB_CURSOR_CONTROL_DEV_INTERFACE));
863   if (!cursor_interface) {
864     NOTREACHED();
865     return;
866   }
867
868   cursor_interface->SetCursor(
869       pp_instance(), cursor_, pp::ImageData().pp_resource(), NULL);
870 }
871
872 void OutOfProcessInstance::UpdateTickMarks(
873     const std::vector<pp::Rect>& tickmarks) {
874   float inverse_scale = 1.0f / device_scale_;
875   std::vector<pp::Rect> scaled_tickmarks = tickmarks;
876   for (size_t i = 0; i < scaled_tickmarks.size(); i++)
877     ScaleRect(inverse_scale, &scaled_tickmarks[i]);
878   tickmarks_ = scaled_tickmarks;
879 }
880
881 void OutOfProcessInstance::NotifyNumberOfFindResultsChanged(int total,
882                                                             bool final_result) {
883   // We don't want to spam the renderer with too many updates to the number of
884   // find results. Don't send an update if we sent one too recently. If it's the
885   // final update, we always send it though.
886   if (final_result) {
887     NumberOfFindResultsChanged(total, final_result);
888     SetTickmarks(tickmarks_);
889     return;
890   }
891
892   if (recently_sent_find_update_)
893     return;
894
895   NumberOfFindResultsChanged(total, final_result);
896   SetTickmarks(tickmarks_);
897   recently_sent_find_update_ = true;
898   pp::CompletionCallback callback =
899       timer_factory_.NewCallback(
900           &OutOfProcessInstance::ResetRecentlySentFindUpdate);
901   pp::Module::Get()->core()->CallOnMainThread(kFindResultCooldownMs,
902                                               callback, 0);
903 }
904
905 void OutOfProcessInstance::NotifySelectedFindResultChanged(
906     int current_find_index) {
907   SelectedFindResultChanged(current_find_index);
908 }
909
910 void OutOfProcessInstance::GetDocumentPassword(
911     pp::CompletionCallbackWithOutput<pp::Var> callback) {
912   if (password_callback_) {
913     NOTREACHED();
914     return;
915   }
916
917   password_callback_.reset(
918       new pp::CompletionCallbackWithOutput<pp::Var>(callback));
919   pp::VarDictionary message;
920   message.Set(pp::Var(kType), pp::Var(kJSGetPasswordType));
921   PostMessage(message);
922 }
923
924 void OutOfProcessInstance::Alert(const std::string& message) {
925   ModalDialog(this, "alert", message, std::string());
926 }
927
928 bool OutOfProcessInstance::Confirm(const std::string& message) {
929   pp::Var result = ModalDialog(this, "confirm", message, std::string());
930   return result.is_bool() ? result.AsBool() : false;
931 }
932
933 std::string OutOfProcessInstance::Prompt(const std::string& question,
934                                          const std::string& default_answer) {
935   pp::Var result = ModalDialog(this, "prompt", question, default_answer);
936   return result.is_string() ? result.AsString() : std::string();
937 }
938
939 std::string OutOfProcessInstance::GetURL() {
940   return url_;
941 }
942
943 void OutOfProcessInstance::Email(const std::string& to,
944                                  const std::string& cc,
945                                  const std::string& bcc,
946                                  const std::string& subject,
947                                  const std::string& body) {
948   pp::VarDictionary message;
949   message.Set(pp::Var(kType), pp::Var(kJSEmailType));
950   message.Set(pp::Var(kJSEmailTo),
951               pp::Var(net::EscapeUrlEncodedData(to, false)));
952   message.Set(pp::Var(kJSEmailCc),
953               pp::Var(net::EscapeUrlEncodedData(cc, false)));
954   message.Set(pp::Var(kJSEmailBcc),
955               pp::Var(net::EscapeUrlEncodedData(bcc, false)));
956   message.Set(pp::Var(kJSEmailSubject),
957               pp::Var(net::EscapeUrlEncodedData(subject, false)));
958   message.Set(pp::Var(kJSEmailBody),
959               pp::Var(net::EscapeUrlEncodedData(body, false)));
960   PostMessage(message);
961 }
962
963 void OutOfProcessInstance::Print() {
964   if (!printing_enabled_ ||
965       (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
966        !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))) {
967     return;
968   }
969
970   pp::CompletionCallback callback =
971       print_callback_factory_.NewCallback(&OutOfProcessInstance::OnPrint);
972   pp::Module::Get()->core()->CallOnMainThread(0, callback);
973 }
974
975 void OutOfProcessInstance::OnPrint(int32_t) {
976   pp::PDF::Print(this);
977 }
978
979 void OutOfProcessInstance::SubmitForm(const std::string& url,
980                                       const void* data,
981                                       int length) {
982   pp::URLRequestInfo request(this);
983   request.SetURL(url);
984   request.SetMethod("POST");
985   request.AppendDataToBody(reinterpret_cast<const char*>(data), length);
986
987   pp::CompletionCallback callback =
988       form_factory_.NewCallback(&OutOfProcessInstance::FormDidOpen);
989   form_loader_ = CreateURLLoaderInternal();
990   int rv = form_loader_.Open(request, callback);
991   if (rv != PP_OK_COMPLETIONPENDING)
992     callback.Run(rv);
993 }
994
995 void OutOfProcessInstance::FormDidOpen(int32_t result) {
996   // TODO: inform the user of success/failure.
997   if (result != PP_OK) {
998     NOTREACHED();
999   }
1000 }
1001
1002 std::string OutOfProcessInstance::ShowFileSelectionDialog() {
1003   // Seems like very low priority to implement, since the pdf has no way to get
1004   // the file data anyways.  Javascript doesn't let you do this synchronously.
1005   NOTREACHED();
1006   return std::string();
1007 }
1008
1009 pp::URLLoader OutOfProcessInstance::CreateURLLoader() {
1010   if (full_) {
1011     if (!did_call_start_loading_) {
1012       did_call_start_loading_ = true;
1013       pp::PDF::DidStartLoading(this);
1014     }
1015
1016     // Disable save and print until the document is fully loaded, since they
1017     // would generate an incomplete document.  Need to do this each time we
1018     // call DidStartLoading since that resets the content restrictions.
1019     pp::PDF::SetContentRestriction(this, CONTENT_RESTRICTION_SAVE |
1020                                    CONTENT_RESTRICTION_PRINT);
1021   }
1022
1023   return CreateURLLoaderInternal();
1024 }
1025
1026 void OutOfProcessInstance::ScheduleCallback(int id, int delay_in_ms) {
1027   pp::CompletionCallback callback =
1028       timer_factory_.NewCallback(&OutOfProcessInstance::OnClientTimerFired);
1029   pp::Module::Get()->core()->CallOnMainThread(delay_in_ms, callback, id);
1030 }
1031
1032 void OutOfProcessInstance::SearchString(const base::char16* string,
1033                             const base::char16* term,
1034                             bool case_sensitive,
1035                             std::vector<SearchStringResult>* results) {
1036   PP_PrivateFindResult* pp_results;
1037   int count = 0;
1038   pp::PDF::SearchString(
1039       this,
1040       reinterpret_cast<const unsigned short*>(string),
1041       reinterpret_cast<const unsigned short*>(term),
1042       case_sensitive,
1043       &pp_results,
1044       &count);
1045
1046   results->resize(count);
1047   for (int i = 0; i < count; ++i) {
1048     (*results)[i].start_index = pp_results[i].start_index;
1049     (*results)[i].length = pp_results[i].length;
1050   }
1051
1052   pp::Memory_Dev memory;
1053   memory.MemFree(pp_results);
1054 }
1055
1056 void OutOfProcessInstance::DocumentPaintOccurred() {
1057 }
1058
1059 void OutOfProcessInstance::DocumentLoadComplete(int page_count) {
1060   // Clear focus state for OSK.
1061   FormTextFieldFocusChange(false);
1062
1063   DCHECK(document_load_state_ == LOAD_STATE_LOADING);
1064   document_load_state_ = LOAD_STATE_COMPLETE;
1065   UserMetricsRecordAction("PDF.LoadSuccess");
1066
1067   // Note: If we are in print preview mode the scroll location is retained
1068   // across document loads so we don't want to scroll again and override it.
1069   if (IsPrintPreview()) {
1070     AppendBlankPrintPreviewPages();
1071     OnGeometryChanged(0, 0);
1072   }
1073
1074   pp::VarDictionary message;
1075   message.Set(pp::Var(kType), pp::Var(kJSLoadProgressType));
1076   message.Set(pp::Var(kJSProgressPercentage), pp::Var(100)) ;
1077   PostMessage(message);
1078
1079   if (!full_)
1080     return;
1081
1082   if (did_call_start_loading_) {
1083     pp::PDF::DidStopLoading(this);
1084     did_call_start_loading_ = false;
1085   }
1086
1087   int content_restrictions =
1088       CONTENT_RESTRICTION_CUT | CONTENT_RESTRICTION_PASTE;
1089   if (!engine_->HasPermission(PDFEngine::PERMISSION_COPY))
1090     content_restrictions |= CONTENT_RESTRICTION_COPY;
1091
1092   if (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
1093       !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY)) {
1094     printing_enabled_ = false;
1095   }
1096
1097   pp::PDF::SetContentRestriction(this, content_restrictions);
1098
1099   uma_.HistogramCustomCounts("PDF.PageCount", page_count,
1100                              1, 1000000, 50);
1101 }
1102
1103 void OutOfProcessInstance::RotateClockwise() {
1104   engine_->RotateClockwise();
1105 }
1106
1107 void OutOfProcessInstance::RotateCounterclockwise() {
1108   engine_->RotateCounterclockwise();
1109 }
1110
1111 void OutOfProcessInstance::PreviewDocumentLoadComplete() {
1112   if (preview_document_load_state_ != LOAD_STATE_LOADING ||
1113       preview_pages_info_.empty()) {
1114     return;
1115   }
1116
1117   preview_document_load_state_ = LOAD_STATE_COMPLETE;
1118
1119   int dest_page_index = preview_pages_info_.front().second;
1120   int src_page_index =
1121       ExtractPrintPreviewPageIndex(preview_pages_info_.front().first);
1122   if (src_page_index > 0 &&  dest_page_index > -1 && preview_engine_.get())
1123     engine_->AppendPage(preview_engine_.get(), dest_page_index);
1124
1125   preview_pages_info_.pop();
1126   // |print_preview_page_count_| is not updated yet. Do not load any
1127   // other preview pages till we get this information.
1128   if (print_preview_page_count_ == 0)
1129     return;
1130
1131   if (preview_pages_info_.size())
1132     LoadAvailablePreviewPage();
1133 }
1134
1135 void OutOfProcessInstance::DocumentLoadFailed() {
1136   DCHECK(document_load_state_ == LOAD_STATE_LOADING);
1137   UserMetricsRecordAction("PDF.LoadFailure");
1138
1139   if (did_call_start_loading_) {
1140     pp::PDF::DidStopLoading(this);
1141     did_call_start_loading_ = false;
1142   }
1143
1144   document_load_state_ = LOAD_STATE_FAILED;
1145   paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
1146
1147   // Send a progress value of -1 to indicate a failure.
1148   pp::VarDictionary message;
1149   message.Set(pp::Var(kType), pp::Var(kJSLoadProgressType));
1150   message.Set(pp::Var(kJSProgressPercentage), pp::Var(-1)) ;
1151   PostMessage(message);
1152 }
1153
1154 void OutOfProcessInstance::PreviewDocumentLoadFailed() {
1155   UserMetricsRecordAction("PDF.PreviewDocumentLoadFailure");
1156   if (preview_document_load_state_ != LOAD_STATE_LOADING ||
1157       preview_pages_info_.empty()) {
1158     return;
1159   }
1160
1161   preview_document_load_state_ = LOAD_STATE_FAILED;
1162   preview_pages_info_.pop();
1163
1164   if (preview_pages_info_.size())
1165     LoadAvailablePreviewPage();
1166 }
1167
1168 pp::Instance* OutOfProcessInstance::GetPluginInstance() {
1169   return this;
1170 }
1171
1172 void OutOfProcessInstance::DocumentHasUnsupportedFeature(
1173     const std::string& feature) {
1174   std::string metric("PDF_Unsupported_");
1175   metric += feature;
1176   if (!unsupported_features_reported_.count(metric)) {
1177     unsupported_features_reported_.insert(metric);
1178     UserMetricsRecordAction(metric);
1179   }
1180
1181   // Since we use an info bar, only do this for full frame plugins..
1182   if (!full_)
1183     return;
1184
1185   if (told_browser_about_unsupported_feature_)
1186     return;
1187   told_browser_about_unsupported_feature_ = true;
1188
1189   pp::PDF::HasUnsupportedFeature(this);
1190 }
1191
1192 void OutOfProcessInstance::DocumentLoadProgress(uint32 available,
1193                                                 uint32 doc_size) {
1194   double progress = 0.0;
1195   if (doc_size == 0) {
1196     // Document size is unknown. Use heuristics.
1197     // We'll make progress logarithmic from 0 to 100M.
1198     static const double kFactor = log(100000000.0) / 100.0;
1199     if (available > 0) {
1200       progress = log(static_cast<double>(available)) / kFactor;
1201       if (progress > 100.0)
1202         progress = 100.0;
1203     }
1204   } else {
1205     progress = 100.0 * static_cast<double>(available) / doc_size;
1206   }
1207
1208   // We send 100% load progress in DocumentLoadComplete.
1209   if (progress >= 100)
1210     return;
1211
1212   // Avoid sending too many progress messages over PostMessage.
1213   if (progress > last_progress_sent_ + 1) {
1214     last_progress_sent_ = progress;
1215     pp::VarDictionary message;
1216     message.Set(pp::Var(kType), pp::Var(kJSLoadProgressType));
1217     message.Set(pp::Var(kJSProgressPercentage), pp::Var(progress)) ;
1218     PostMessage(message);
1219   }
1220 }
1221
1222 void OutOfProcessInstance::FormTextFieldFocusChange(bool in_focus) {
1223   if (!text_input_.get())
1224     return;
1225   if (in_focus)
1226     text_input_->SetTextInputType(PP_TEXTINPUT_TYPE_DEV_TEXT);
1227   else
1228     text_input_->SetTextInputType(PP_TEXTINPUT_TYPE_DEV_NONE);
1229 }
1230
1231 void OutOfProcessInstance::ResetRecentlySentFindUpdate(int32_t /* unused */) {
1232   recently_sent_find_update_ = false;
1233 }
1234
1235 void OutOfProcessInstance::OnGeometryChanged(double old_zoom,
1236                                              float old_device_scale) {
1237   if (zoom_ != old_zoom || device_scale_ != old_device_scale)
1238     engine_->ZoomUpdated(zoom_ * device_scale_);
1239
1240   available_area_ = pp::Rect(plugin_size_);
1241   int doc_width = GetDocumentPixelWidth();
1242   if (doc_width < available_area_.width()) {
1243     available_area_.Offset((available_area_.width() - doc_width) / 2, 0);
1244     available_area_.set_width(doc_width);
1245   }
1246   int doc_height = GetDocumentPixelHeight();
1247   if (doc_height < available_area_.height()) {
1248     available_area_.set_height(doc_height);
1249   }
1250
1251   CalculateBackgroundParts();
1252   engine_->PageOffsetUpdated(available_area_.point());
1253   engine_->PluginSizeUpdated(available_area_.size());
1254
1255   if (!document_size_.GetArea())
1256     return;
1257   paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
1258 }
1259
1260 void OutOfProcessInstance::LoadUrl(const std::string& url) {
1261   LoadUrlInternal(url, &embed_loader_, &OutOfProcessInstance::DidOpen);
1262 }
1263
1264 void OutOfProcessInstance::LoadPreviewUrl(const std::string& url) {
1265   LoadUrlInternal(url, &embed_preview_loader_,
1266                   &OutOfProcessInstance::DidOpenPreview);
1267 }
1268
1269 void OutOfProcessInstance::LoadUrlInternal(
1270     const std::string& url,
1271     pp::URLLoader* loader,
1272     void (OutOfProcessInstance::* method)(int32_t)) {
1273   pp::URLRequestInfo request(this);
1274   request.SetURL(url);
1275   request.SetMethod("GET");
1276
1277   *loader = CreateURLLoaderInternal();
1278   pp::CompletionCallback callback = loader_factory_.NewCallback(method);
1279   int rv = loader->Open(request, callback);
1280   if (rv != PP_OK_COMPLETIONPENDING)
1281     callback.Run(rv);
1282 }
1283
1284 pp::URLLoader OutOfProcessInstance::CreateURLLoaderInternal() {
1285   pp::URLLoader loader(this);
1286
1287   const PPB_URLLoaderTrusted* trusted_interface =
1288       reinterpret_cast<const PPB_URLLoaderTrusted*>(
1289           pp::Module::Get()->GetBrowserInterface(
1290               PPB_URLLOADERTRUSTED_INTERFACE));
1291   if (trusted_interface)
1292     trusted_interface->GrantUniversalAccess(loader.pp_resource());
1293   return loader;
1294 }
1295
1296 void OutOfProcessInstance::SetZoom(double scale) {
1297   double old_zoom = zoom_;
1298   zoom_ = scale;
1299   OnGeometryChanged(old_zoom, device_scale_);
1300 }
1301
1302 std::string OutOfProcessInstance::GetLocalizedString(PP_ResourceString id) {
1303   pp::Var rv(pp::PDF::GetLocalizedString(this, id));
1304   if (!rv.is_string())
1305     return std::string();
1306
1307   return rv.AsString();
1308 }
1309
1310 void OutOfProcessInstance::AppendBlankPrintPreviewPages() {
1311   if (print_preview_page_count_ == 0)
1312     return;
1313   engine_->AppendBlankPages(print_preview_page_count_);
1314   if (preview_pages_info_.size() > 0)
1315     LoadAvailablePreviewPage();
1316 }
1317
1318 bool OutOfProcessInstance::IsPrintPreview() {
1319   return IsPrintPreviewUrl(url_);
1320 }
1321
1322 void OutOfProcessInstance::ProcessPreviewPageInfo(const std::string& url,
1323                                                   int dst_page_index) {
1324   if (!IsPrintPreview())
1325     return;
1326
1327   int src_page_index = ExtractPrintPreviewPageIndex(url);
1328   if (src_page_index < 1)
1329     return;
1330
1331   preview_pages_info_.push(std::make_pair(url, dst_page_index));
1332   LoadAvailablePreviewPage();
1333 }
1334
1335 void OutOfProcessInstance::LoadAvailablePreviewPage() {
1336   if (preview_pages_info_.size() <= 0 ||
1337       document_load_state_ != LOAD_STATE_COMPLETE) {
1338     return;
1339   }
1340
1341   std::string url = preview_pages_info_.front().first;
1342   int dst_page_index = preview_pages_info_.front().second;
1343   int src_page_index = ExtractPrintPreviewPageIndex(url);
1344   if (src_page_index < 1 ||
1345       dst_page_index >= print_preview_page_count_ ||
1346       preview_document_load_state_ == LOAD_STATE_LOADING) {
1347     return;
1348   }
1349
1350   preview_document_load_state_ = LOAD_STATE_LOADING;
1351   LoadPreviewUrl(url);
1352 }
1353
1354 void OutOfProcessInstance::UserMetricsRecordAction(
1355     const std::string& action) {
1356   // TODO(raymes): Move this function to PPB_UMA_Private.
1357   pp::PDF::UserMetricsRecordAction(this, pp::Var(action));
1358 }
1359
1360 pp::Point OutOfProcessInstance::BoundScrollOffsetToDocument(
1361     const pp::Point& scroll_offset) {
1362   int max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
1363   int x = std::max(std::min(scroll_offset.x(), max_x), 0);
1364   int max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
1365   int y = std::max(std::min(scroll_offset.y(), max_y), 0);
1366   return pp::Point(x, y);
1367 }
1368
1369 }  // namespace chrome_pdf