Cleanup PDF plugin code.

pdf/out_of_process_instance.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "pdf/out_of_process_instance.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>       // for min/max()
@@ skipping 281 matching lines @@
       print_preview_page_count_(0),
       last_progress_sent_(0),
       recently_sent_find_update_(false),
       received_viewport_message_(false),
       did_call_start_loading_(false),
       stop_scrolling_(false),
       background_color_(0),
       top_toolbar_height_(0),
       accessibility_state_(ACCESSIBILITY_STATE_OFF),
       is_print_preview_(false) {
-  loader_factory_.Initialize(this);
-  timer_factory_.Initialize(this);
-  form_factory_.Initialize(this);
-  print_callback_factory_.Initialize(this);
-  engine_.reset(PDFEngine::Create(this));
+  callback_factory_.Initialize(this);
+  engine_ = PDFEngine::Create(this);
   pp::Module::Get()->AddPluginInterface(kPPPPdfInterface, &ppp_private);
   AddPerInstanceObject(kPPPPdfInterface, this);
 
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_TOUCH);
 }
 
 OutOfProcessInstance::~OutOfProcessInstance() {
   RemovePerInstanceObject(kPPPPdfInterface, this);
@@ skipping 60 matching lines @@
   if (!stream_url)
     stream_url = original_url;
 
   // If we're in print preview mode we don't need to load the document yet.
   // A |kJSResetPrintPreviewModeType| message will be sent to the plugin letting
   // it know the url to load. By not loading here we avoid loading the same
   // document twice.
   if (IsPrintPreview())
     return true;
 
-  LoadUrl(stream_url);
+  LoadUrl(stream_url, /*is_print_preview=*/false);
   url_ = original_url;
   pp::PDF::SetCrashData(GetPluginInstance(), original_url, top_level_url);
   return engine_->New(original_url, headers);
 }
 
 void OutOfProcessInstance::HandleMessage(const pp::Var& message) {
   pp::VarDictionary dict(message);
   if (!dict.Get(kType).is_string()) {
     NOTREACHED();
     return;
@@ skipping 130 matching lines @@
              dict.Get(pp::Var(kJSPrintPreviewGrayscale)).is_bool() &&
              dict.Get(pp::Var(kJSPrintPreviewPageCount)).is_int()) {
     url_ = dict.Get(pp::Var(kJSPrintPreviewUrl)).AsString();
     // For security reasons we crash if the URL that is trying to be loaded here
     // isn't a print preview one.
     CHECK(IsPrintPreview());
     CHECK(IsPrintPreviewUrl(url_));
     preview_pages_info_ = std::queue<PreviewPageInfo>();
     preview_document_load_state_ = LOAD_STATE_COMPLETE;
     document_load_state_ = LOAD_STATE_LOADING;
-    LoadUrl(url_);
+    LoadUrl(url_, /*is_print_preview=*/false);
     preview_engine_.reset();
-    engine_.reset(PDFEngine::Create(this));
+    engine_ = PDFEngine::Create(this);
     engine_->SetGrayscale(dict.Get(pp::Var(kJSPrintPreviewGrayscale)).AsBool());
     engine_->New(url_.c_str(), nullptr /* empty header */);
 
     print_preview_page_count_ =
         std::max(dict.Get(pp::Var(kJSPrintPreviewPageCount)).AsInt(), 0);
 
     paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
   } else if (type == kJSLoadPreviewPageType &&
              dict.Get(pp::Var(kJSPreviewPageUrl)).is_string() &&
              dict.Get(pp::Var(kJSPreviewPageIndex)).is_int()) {
@@ skipping 160 matching lines @@
 
   // If the document contents isn't accessible, don't send anything more.
   if (!(engine_->HasPermission(PDFEngine::PERMISSION_COPY) ||
         engine_->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE))) {
     return;
   }
 
   SendAccessibilityViewportInfo();
 
   // Schedule loading the first page.
-  pp::CompletionCallback callback = timer_factory_.NewCallback(
+  pp::CompletionCallback callback = callback_factory_.NewCallback(
       &OutOfProcessInstance::SendNextAccessibilityPage);
   pp::Module::Get()->core()->CallOnMainThread(kAccessibilityPageDelayMs,
                                               callback, 0);
 }
 
 void OutOfProcessInstance::SendNextAccessibilityPage(int32_t page_index) {
   int page_count = engine_->GetNumberOfPages();
   if (page_index < 0 || page_index >= page_count)
     return;
 
@@ skipping 45 matching lines @@
     chars[char_index + text_run_info.len - 1].char_width = char_bounds.width();
 
     char_index += text_run_info.len;
   }
 
   page_info.text_run_count = text_runs.size();
   pp::PDF::SetAccessibilityPageInfo(GetPluginInstance(), &page_info,
                                     text_runs.data(), chars.data());
 
   // Schedule loading the next page.
-  pp::CompletionCallback callback = timer_factory_.NewCallback(
+  pp::CompletionCallback callback = callback_factory_.NewCallback(
       &OutOfProcessInstance::SendNextAccessibilityPage);
   pp::Module::Get()->core()->CallOnMainThread(kAccessibilityPageDelayMs,
                                               callback, page_index + 1);
 }
 
 void OutOfProcessInstance::SendAccessibilityViewportInfo() {
   PP_PrivateAccessibilityViewportInfo viewport_info;
   viewport_info.scroll.x = 0;
   viewport_info.scroll.y = -top_toolbar_height_ * device_scale_;
   viewport_info.offset = available_area_.point();
@@ skipping 153 matching lines @@
   if (engine_->IsProgressiveLoad()) {
     pp::VarDictionary message;
     message.Set(kType, kJSCancelStreamUrlType);
     PostMessage(message);
   }
 }
 
 void OutOfProcessInstance::DidOpenPreview(int32_t result) {
   if (result == PP_OK) {
     preview_client_ = base::MakeUnique<PreviewModeClient>(this);
-    preview_engine_.reset(PDFEngine::Create(preview_client_.get()));
+    preview_engine_ = PDFEngine::Create(preview_client_.get());
     preview_engine_->HandleDocumentLoad(embed_preview_loader_);
   } else {
     NOTREACHED();
   }
 }
 
 void OutOfProcessInstance::OnClientTimerFired(int32_t id) {
   engine_->OnCallback(id);
 }
 
@@ skipping 147 matching lines @@
     SetTickmarks(tickmarks_);
     return;
   }
 
   if (recently_sent_find_update_)
     return;
 
   NumberOfFindResultsChanged(total, final_result);
   SetTickmarks(tickmarks_);
   recently_sent_find_update_ = true;
-  pp::CompletionCallback callback = timer_factory_.NewCallback(
+  pp::CompletionCallback callback = callback_factory_.NewCallback(
       &OutOfProcessInstance::ResetRecentlySentFindUpdate);
   pp::Module::Get()->core()->CallOnMainThread(kFindResultCooldownMs, callback,
                                               0);
 }
 
 void OutOfProcessInstance::NotifySelectedFindResultChanged(
     int current_find_index) {
   DCHECK_GE(current_find_index, 0);
   SelectedFindResultChanged(current_find_index);
 }
@@ skipping 51 matching lines @@
   PostMessage(message);
 }
 
 void OutOfProcessInstance::Print() {
   if (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
       !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY)) {
     return;
   }
 
   pp::CompletionCallback callback =
-      print_callback_factory_.NewCallback(&OutOfProcessInstance::OnPrint);
+      callback_factory_.NewCallback(&OutOfProcessInstance::OnPrint);
   pp::Module::Get()->core()->CallOnMainThread(0, callback);
 }
 
 void OutOfProcessInstance::OnPrint(int32_t) {
   pp::PDF::Print(this);
 }
 
 void OutOfProcessInstance::SubmitForm(const std::string& url,
                                       const void* data,
                                       int length) {
   pp::URLRequestInfo request(this);
   request.SetURL(url);
   request.SetMethod("POST");
   request.AppendDataToBody(reinterpret_cast<const char*>(data), length);
 
   pp::CompletionCallback callback =
-      form_factory_.NewCallback(&OutOfProcessInstance::FormDidOpen);
+      callback_factory_.NewCallback(&OutOfProcessInstance::FormDidOpen);
   form_loader_ = CreateURLLoaderInternal();
   int rv = form_loader_.Open(request, callback);
   if (rv != PP_OK_COMPLETIONPENDING)
     callback.Run(rv);
 }
 
 void OutOfProcessInstance::FormDidOpen(int32_t result) {
   // TODO: inform the user of success/failure.
   if (result != PP_OK) {
     NOTREACHED();
@@ skipping 19 matching lines @@
     // call DidStartLoading since that resets the content restrictions.
     pp::PDF::SetContentRestriction(
         this, CONTENT_RESTRICTION_SAVE | CONTENT_RESTRICTION_PRINT);
   }
 
   return CreateURLLoaderInternal();
 }
 
 void OutOfProcessInstance::ScheduleCallback(int id, int delay_in_ms) {
   pp::CompletionCallback callback =
-      timer_factory_.NewCallback(&OutOfProcessInstance::OnClientTimerFired);
+      callback_factory_.NewCallback(&OutOfProcessInstance::OnClientTimerFired);
   pp::Module::Get()->core()->CallOnMainThread(delay_in_ms, callback, id);
 }
 
 void OutOfProcessInstance::SearchString(
     const base::char16* string,
     const base::char16* term,
     bool case_sensitive,
     std::vector<SearchStringResult>* results) {
   PP_PrivateFindResult* pp_results;
   int count = 0;
@@ skipping 88 matching lines @@
 }
 
 void OutOfProcessInstance::PreviewDocumentLoadComplete() {
   if (preview_document_load_state_ != LOAD_STATE_LOADING ||
       preview_pages_info_.empty()) {
     return;
   }
 
   preview_document_load_state_ = LOAD_STATE_COMPLETE;
 
+  const std::string& url = preview_pages_info_.front().first;
   int dest_page_index = preview_pages_info_.front().second;
-  int src_page_index =
-      ExtractPrintPreviewPageIndex(preview_pages_info_.front().first);
-  if (src_page_index > 0 && dest_page_index > -1 && preview_engine_.get())
+  int src_page_index = ExtractPrintPreviewPageIndex(url);
+  if (src_page_index > 0 && dest_page_index > -1 && preview_engine_)
     engine_->AppendPage(preview_engine_.get(), dest_page_index);
 
   preview_pages_info_.pop();
   // |print_preview_page_count_| is not updated yet. Do not load any
-  // other preview pages till we get this information.
+  // other preview pages until this information is available.
   if (print_preview_page_count_ == 0)
     return;
 
   if (!preview_pages_info_.empty())
     LoadAvailablePreviewPage();
 }
 
 void OutOfProcessInstance::DocumentLoadFailed() {
   DCHECK_EQ(LOAD_STATE_LOADING, document_load_state_);
   UserMetricsRecordAction("PDF.LoadFailure");
@@ skipping 79 matching lines @@
   if (progress > last_progress_sent_ + 1) {
     last_progress_sent_ = progress;
     pp::VarDictionary message;
     message.Set(pp::Var(kType), pp::Var(kJSLoadProgressType));
     message.Set(pp::Var(kJSProgressPercentage), pp::Var(progress));
     PostMessage(message);
   }
 }
 
 void OutOfProcessInstance::FormTextFieldFocusChange(bool in_focus) {
-  if (!text_input_.get())
+  if (!text_input_)
     return;
 
   pp::VarDictionary message;
   message.Set(pp::Var(kType), pp::Var(kJSFieldFocusType));
   message.Set(pp::Var(kJSFieldFocus), pp::Var(in_focus));
   PostMessage(message);
 
   text_input_->SetTextInputType(in_focus ? PP_TEXTINPUT_TYPE_DEV_TEXT
                                          : PP_TEXTINPUT_TYPE_DEV_NONE);
 }
@@ skipping 23 matching lines @@
   engine_->PluginSizeUpdated(available_area_.size());
 
   if (document_size_.IsEmpty())
     return;
   paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
 
   if (accessibility_state_ == ACCESSIBILITY_STATE_LOADED)
     SendAccessibilityViewportInfo();
 }
 
-void OutOfProcessInstance::LoadUrl(const std::string& url) {
-  LoadUrlInternal(url, &embed_loader_, &OutOfProcessInstance::DidOpen);
-}
-
-void OutOfProcessInstance::LoadPreviewUrl(const std::string& url) {
-  LoadUrlInternal(url, &embed_preview_loader_,
-                  &OutOfProcessInstance::DidOpenPreview);
-}
-
-void OutOfProcessInstance::LoadUrlInternal(
-    const std::string& url,
-    pp::URLLoader* loader,
-    void (OutOfProcessInstance::*method)(int32_t)) {
+void OutOfProcessInstance::LoadUrl(const std::string& url,
+                                   bool is_print_preview) {
   pp::URLRequestInfo request(this);
   request.SetURL(url);
   request.SetMethod("GET");
   request.SetFollowRedirects(false);
 
+  pp::URLLoader* loader =
+      is_print_preview ? &embed_preview_loader_ : &embed_loader_;
   *loader = CreateURLLoaderInternal();
-  pp::CompletionCallback callback = loader_factory_.NewCallback(method);
+  pp::CompletionCallback callback = callback_factory_.NewCallback(
+      is_print_preview ? &OutOfProcessInstance::DidOpenPreview
+                       : &OutOfProcessInstance::DidOpen);
   int rv = loader->Open(request, callback);
   if (rv != PP_OK_COMPLETIONPENDING)
     callback.Run(rv);
 }
 
 pp::URLLoader OutOfProcessInstance::CreateURLLoaderInternal() {
   pp::URLLoader loader(this);
 
   const PPB_URLLoaderTrusted* trusted_interface =
       reinterpret_cast<const PPB_URLLoaderTrusted*>(
@@ skipping 44 matching lines @@
   preview_pages_info_.push(std::make_pair(url, dst_page_index));
   LoadAvailablePreviewPage();
 }
 
 void OutOfProcessInstance::LoadAvailablePreviewPage() {
   if (preview_pages_info_.empty() ||
       document_load_state_ != LOAD_STATE_COMPLETE) {
     return;
   }
 
-  std::string url = preview_pages_info_.front().first;
+  const std::string& url = preview_pages_info_.front().first;
   int dst_page_index = preview_pages_info_.front().second;
   int src_page_index = ExtractPrintPreviewPageIndex(url);
   if (src_page_index < 1 || dst_page_index >= print_preview_page_count_ ||
       preview_document_load_state_ == LOAD_STATE_LOADING) {
     return;
   }
 
   preview_document_load_state_ = LOAD_STATE_LOADING;
-  LoadPreviewUrl(url);
+  LoadUrl(url, /*is_print_preview=*/true);
 }
 
 void OutOfProcessInstance::UserMetricsRecordAction(const std::string& action) {
   // TODO(raymes): Move this function to PPB_UMA_Private.
   pp::PDF::UserMetricsRecordAction(this, pp::Var(action));
 }
 
 pp::FloatPoint OutOfProcessInstance::BoundScrollOffsetToDocument(
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
   float min_y = -top_toolbar_height_;
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf