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