PDF: Fix some nits in OutOfProcessInstance.

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()
 #define _USE_MATH_DEFINES  // for M_PI
 #include <cmath>      // for log() and pow()
 #include <math.h>
 #include <list>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/content_restriction.h"
 #include "net/base/escape.h"
 #include "pdf/pdf.h"
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 11 matching lines @@
 #include "ppapi/cpp/private/var_private.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/resource.h"
 #include "ppapi/cpp/url_request_info.h"
 #include "ppapi/cpp/var_array.h"
 #include "ppapi/cpp/var_dictionary.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 namespace chrome_pdf {
 
+namespace {
+
 const char kChromePrint[] = "chrome://print/";
 const char kChromeExtension[] =
     "chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai";
 
 // Constants used in handling postMessage() messages.
 const char kType[] = "type";
 // Viewport message arguments. (Page -> Plugin).
 const char kJSViewportType[] = "viewport";
 const char kJSXOffset[] = "xOffset";
 const char kJSYOffset[] = "yOffset";
@@ skipping 88 matching lines @@
 const char kJSFieldFocus[] = "focused";
 
 const int kFindResultCooldownMs = 100;
 
 // A delay to wait between each accessibility page to keep the system
 // responsive.
 const int kAccessibilityPageDelayMs = 100;
 
 const double kMinZoom = 0.01;
 
-namespace {
-
-static const char kPPPPdfInterface[] = PPP_PDF_INTERFACE_1;
+const char kPPPPdfInterface[] = PPP_PDF_INTERFACE_1;
 
 // Used for UMA. Do not delete entries, and keep in sync with histograms.xml.
 enum PDFFeatures {
   LOADED_DOCUMENT = 0,
   HAS_TITLE = 1,
   HAS_BOOKMARKS = 2,
   FEATURES_COUNT
 };
 
 PP_Var GetLinkAtPosition(PP_Instance instance, PP_Point point) {
@@ skipping 93 matching lines @@
                     const std::string& message,
                     const std::string& default_answer) {
   const PPB_Instance_Private* interface =
       reinterpret_cast<const PPB_Instance_Private*>(
           pp::Module::Get()->GetBrowserInterface(
               PPB_INSTANCE_PRIVATE_INTERFACE));
   pp::VarPrivate window(pp::PASS_REF,
       interface->GetWindowObject(instance->pp_instance()));
   if (default_answer.empty())
     return window.Call(type, message);
-  else
-    return window.Call(type, message, default_answer);
+  return window.Call(type, message, default_answer);
 }
 
 }  // namespace
 
 OutOfProcessInstance::OutOfProcessInstance(PP_Instance instance)
     : pp::Instance(instance),
       pp::Find_Private(this),
       pp::Printing_Dev(this),
       cursor_(PP_CURSORTYPE_POINTER),
       zoom_(1.0),
@@ skipping 61 matching lines @@
     if (strcmp(argn[i], "full-frame") == 0) {
       full_ = true;
       break;
     }
   }
 
   // Only allow the plugin to handle find requests if it is full frame.
   if (full_)
     SetPluginToHandleFindRequests();
 
-  text_input_.reset(new pp::TextInput_Dev(this));
+  text_input_ = base::MakeUnique<pp::TextInput_Dev>(this);
 
   const char* stream_url = nullptr;
   const char* original_url = nullptr;
   const char* top_level_url = nullptr;
   const char* headers = nullptr;
   for (uint32_t i = 0; i < argc; ++i) {
     bool success = true;
     if (strcmp(argn[i], "src") == 0)
       original_url = argv[i];
     else if (strcmp(argn[i], "stream-url") == 0)
@@ skipping 171 matching lines @@
     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()) {
-
     std::string url = dict.Get(pp::Var(kJSPreviewPageUrl)).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));
     ProcessPreviewPageInfo(url,
                            dict.Get(pp::Var(kJSPreviewPageIndex)).AsInt());
   } else if (type == kJSStopScrollingType) {
     stop_scrolling_ = true;
   } else if (type == kJSGetSelectedTextType) {
@@ skipping 385 matching lines @@
   engine_->PostPaint();
 }
 
 void OutOfProcessInstance::DidOpen(int32_t result) {
   if (result != PP_OK || !engine_->HandleDocumentLoad(embed_loader_))
     DocumentLoadFailed();
 }
 
 void OutOfProcessInstance::DidOpenPreview(int32_t result) {
   if (result == PP_OK) {
-    preview_client_.reset(new PreviewModeClient(this));
+    preview_client_ = base::MakeUnique<PreviewModeClient>(this);
     preview_engine_.reset(PDFEngine::Create(preview_client_.get()));
     preview_engine_->HandleDocumentLoad(embed_preview_loader_);
   } else {
     NOTREACHED();
   }
 }
 
 void OutOfProcessInstance::OnClientTimerFired(int32_t id) {
   engine_->OnCallback(id);
 }
@@ skipping 170 matching lines @@
   SelectedFindResultChanged(current_find_index);
 }
 
 void OutOfProcessInstance::GetDocumentPassword(
     pp::CompletionCallbackWithOutput<pp::Var> callback) {
   if (password_callback_) {
     NOTREACHED();
     return;
   }
 
-  password_callback_.reset(
-      new pp::CompletionCallbackWithOutput<pp::Var>(callback));
+  password_callback_ =
+      base::MakeUnique<pp::CompletionCallbackWithOutput<pp::Var>>(callback);
   pp::VarDictionary message;
   message.Set(pp::Var(kType), pp::Var(kJSGetPasswordType));
   PostMessage(message);
 }
 
 void OutOfProcessInstance::Alert(const std::string& message) {
   ModalDialog(this, "alert", message, std::string());
 }
 
 bool OutOfProcessInstance::Confirm(const std::string& message) {
@@ skipping 123 matching lines @@
   memory.MemFree(pp_results);
 }
 
 void OutOfProcessInstance::DocumentPaintOccurred() {
 }
 
 void OutOfProcessInstance::DocumentLoadComplete(int page_count) {
   // Clear focus state for OSK.
   FormTextFieldFocusChange(false);
 
-  DCHECK(document_load_state_ == LOAD_STATE_LOADING);
+  DCHECK_EQ(LOAD_STATE_LOADING, document_load_state_);
   document_load_state_ = LOAD_STATE_COMPLETE;
   UserMetricsRecordAction("PDF.LoadSuccess");
   uma_.HistogramEnumeration("PDF.DocumentFeature", LOADED_DOCUMENT,
                             FEATURES_COUNT);
   if (!font_substitution_reported_)
     uma_.HistogramEnumeration("PDF.IsFontSubstituted", 0, 2);
 
   // Note: If we are in print preview mode the scroll location is retained
   // across document loads so we don't want to scroll again and override it.
   if (IsPrintPreview()) {
@@ skipping 74 matching lines @@
   // |print_preview_page_count_| is not updated yet. Do not load any
   // other preview pages till we get this information.
   if (print_preview_page_count_ == 0)
     return;
 
   if (!preview_pages_info_.empty())
     LoadAvailablePreviewPage();
 }
 
 void OutOfProcessInstance::DocumentLoadFailed() {
-  DCHECK(document_load_state_ == LOAD_STATE_LOADING);
+  DCHECK_EQ(LOAD_STATE_LOADING, document_load_state_);
   UserMetricsRecordAction("PDF.LoadFailure");
 
   if (did_call_start_loading_) {
     pp::PDF::DidStopLoading(this);
     did_call_start_loading_ = false;
   }
 
   document_load_state_ = LOAD_STATE_FAILED;
   paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
 
@@ skipping 45 matching lines @@
   if (told_browser_about_unsupported_feature_)
     return;
   told_browser_about_unsupported_feature_ = true;
 
   pp::PDF::HasUnsupportedFeature(this);
 }
 
 void OutOfProcessInstance::DocumentLoadProgress(uint32_t available,
                                                 uint32_t doc_size) {
   double progress = 0.0;
-  if (doc_size == 0) {
+  if (doc_size) {
+    progress = 100.0 * static_cast<double>(available) / doc_size;
+  } else {
     // Document size is unknown. Use heuristics.
     // We'll make progress logarithmic from 0 to 100M.
     static const double kFactor = log(100000000.0) / 100.0;
-    if (available > 0) {
-      progress = log(static_cast<double>(available)) / kFactor;
-      if (progress > 100.0)
-        progress = 100.0;
-    }
-  } else {
-    progress = 100.0 * static_cast<double>(available) / doc_size;
+    if (available > 0)
+      progress = std::min(log(static_cast<double>(available)) / kFactor, 100.0);
   }
 
   // We send 100% load progress in DocumentLoadComplete.
   if (progress >= 100)
     return;
 
   // Avoid sending too many progress messages over PostMessage.
   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())
     return;
 
   pp::VarDictionary message;
   message.Set(pp::Var(kType), pp::Var(kJSFieldFocusType));
   message.Set(pp::Var(kJSFieldFocus), pp::Var(in_focus));
   PostMessage(message);
 
-  if (in_focus)
-    text_input_->SetTextInputType(PP_TEXTINPUT_TYPE_DEV_TEXT);
-  else
-    text_input_->SetTextInputType(PP_TEXTINPUT_TYPE_DEV_NONE);
+  text_input_->SetTextInputType(in_focus ? PP_TEXTINPUT_TYPE_DEV_TEXT
+                                         : PP_TEXTINPUT_TYPE_DEV_NONE);
 }
 
 void OutOfProcessInstance::ResetRecentlySentFindUpdate(int32_t /* unused */) {
   recently_sent_find_update_ = false;
 }
 
 void OutOfProcessInstance::OnGeometryChanged(double old_zoom,
                                              float old_device_scale) {
   if (zoom_ != old_zoom || device_scale_ != old_device_scale)
     engine_->ZoomUpdated(zoom_ * device_scale_);
@@ skipping 134 matching lines @@
     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