Use more StringPieces in the PDF plugin.

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 <math.h>
 #include <cmath>  // for log() and pow()
 #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 "chrome/common/url_constants.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"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/private/ppb_instance_private.h"
 #include "ppapi/c/private/ppp_pdf.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/cpp/core.h"
 #include "ppapi/cpp/dev/memory_dev.h"
 #include "ppapi/cpp/dev/text_input_dev.h"
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/private/pdf.h"
 #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";
 const char kJSZoom[] = "zoom";
@@ skipping 149 matching lines @@
         static_cast<OutOfProcessInstance*>(object);
     return obj_instance->EnableAccessibility();
   }
 }
 
 const PPP_Pdf ppp_private = {
     &GetLinkAtPosition, &Transform, &GetPrintPresetOptionsFromDocument,
     &EnableAccessibility,
 };
 
-int ExtractPrintPreviewPageIndex(const std::string& src_url) {
+int ExtractPrintPreviewPageIndex(base::StringPiece src_url) {
   // Sample |src_url| format: chrome://print/id/page_index/print.pdf
-  std::vector<std::string> url_substr =
-      base::SplitString(src_url.substr(strlen(kChromePrint)), "/",
-                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<base::StringPiece> url_substr =
+      base::SplitStringPiece(src_url.substr(strlen(chrome::kChromeUIPrintURL)),
+                             "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (url_substr.size() != 3)
     return -1;
 
   if (url_substr[2] != "print.pdf")
     return -1;
 
   int page_index = 0;
   if (!base::StringToInt(url_substr[1], &page_index))
     return -1;
   return page_index;
 }
 
-bool IsPrintPreviewUrl(const std::string& url) {
-  return url.substr(0, strlen(kChromePrint)) == kChromePrint;
+bool IsPrintPreviewUrl(base::StringPiece url) {
+  return url.starts_with(chrome::kChromeUIPrintURL);
 }
 
 void ScalePoint(float scale, pp::Point* point) {
   point->set_x(static_cast<int>(point->x() * scale));
   point->set_y(static_cast<int>(point->y() * scale));
 }
 
 void ScaleRect(float scale, pp::Rect* rect) {
   int left = static_cast<int>(floorf(rect->x() * scale));
   int top = static_cast<int>(floorf(rect->y() * scale));
@@ skipping 70 matching lines @@
                                 const char* argn[],
                                 const char* argv[]) {
   // Check if the PDF is being loaded in the PDF chrome extension. We only allow
   // the plugin to be loaded in the extension and print preview to avoid
   // exposing sensitive APIs directly to external websites.
   pp::Var document_url_var = pp::URLUtil_Dev::Get()->GetDocumentURL(this);
   if (!document_url_var.is_string())
     return false;
   std::string document_url = document_url_var.AsString();
   base::StringPiece document_url_piece(document_url);
-  is_print_preview_ = document_url_piece.starts_with(kChromePrint);
-  if (!document_url_piece.starts_with(kChromeExtension) && !is_print_preview_) {
+  is_print_preview_ = IsPrintPreviewUrl(document_url_piece);
+  if (!document_url_piece.starts_with(kChromeExtension) && !is_print_preview_)
     return false;
-  }
 
   // Check if the plugin is full frame. This is passed in from JS.
   for (uint32_t i = 0; i < argc; ++i) {
     if (strcmp(argn[i], "full-frame") == 0) {
       full_ = true;
       break;
     }
   }
 
   // Allow the plugin to handle find requests.
@@ skipping 1222 matching lines @@
 }
 
 void OutOfProcessInstance::IsSelectingChanged(bool is_selecting) {
   pp::VarDictionary message;
   message.Set(kType, kJSSetIsSelectingType);
   message.Set(kJSIsSelecting, pp::Var(is_selecting));
   PostMessage(message);
 }
 
 void OutOfProcessInstance::ProcessPreviewPageInfo(const std::string& url,
-                                                  int dst_page_index) {
+                                                  int dest_page_index) {
   DCHECK(IsPrintPreview());
 
   int src_page_index = ExtractPrintPreviewPageIndex(url);
   if (src_page_index < 1)
     return;
 
-  preview_pages_info_.push(std::make_pair(url, dst_page_index));
+  preview_pages_info_.push(std::make_pair(url, dest_page_index));
   LoadAvailablePreviewPage();
 }
 
 void OutOfProcessInstance::LoadAvailablePreviewPage() {
   if (preview_pages_info_.empty() ||
       document_load_state_ != LOAD_STATE_COMPLETE) {
     return;
   }
 
   const std::string& url = preview_pages_info_.front().first;
-  int dst_page_index = preview_pages_info_.front().second;
+  int dest_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_ ||
+  if (src_page_index < 1 || dest_page_index >= print_preview_page_count_ ||
       preview_document_load_state_ == LOAD_STATE_LOADING) {
     return;
   }
 
   preview_document_load_state_ = LOAD_STATE_LOADING;
   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