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