Remove most references to VarPrivate/InstancePrivate from OOP PDF

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 <algorithm>  // for min/max()
 #define _USE_MATH_DEFINES  // for M_PI
 #include <cmath>      // for log() and pow()
 #include <math.h>
 #include <list>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/common/content_restriction.h"
 #include "net/base/escape.h"
 #include "pdf/draw_utils.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/rect.h"
@@ skipping 73 matching lines @@
 const char* kJSLoadingString = "loadingString";
 const char* kJSLoadFailedString = "loadFailedString";
 // Request accessibility JSON data (Page -> Plugin)
 const char* kJSGetAccessibilityJSONType = "getAccessibilityJSON";
 const char* kJSAccessibilityPageNumber = "page";
 // Reply with accessibility JSON data (Plugin -> Page)
 const char* kJSGetAccessibilityJSONReplyType = "getAccessibilityJSONReply";
 const char* kJSAccessibilityJSON = "json";
 // Cancel the stream URL request (Plugin -> Page)
 const char* kJSCancelStreamUrlType = "cancelStreamUrl";
+// Navigate to the given URL (Plugin -> Page)
+const char* kJSNavigateType = "navigate";
+const char* kJSNavigateUrl = "url";
+const char* kJSNavigateNewTab = "newTab";
+// Open the email editor with the given parameters (Plugin -> Page)
+const char* kJSEmailType = "email";
+const char* kJSEmailTo = "to";
+const char* kJSEmailCc = "cc";
+const char* kJSEmailBcc = "bcc";
+const char* kJSEmailSubject = "subject";
+const char* kJSEmailBody = "body";
 
 const int kFindResultCooldownMs = 100;
 
 const double kMinZoom = 0.01;
 
 namespace {
 
 static const char kPPPPdfInterface[] = PPP_PDF_INTERFACE_1;
 
 PP_Var GetLinkAtPosition(PP_Instance instance, PP_Point point) {
@@ skipping 54 matching lines @@
 }
 
 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));
   int right = static_cast<int>(ceilf((rect->x() + rect->width()) * scale));
   int bottom = static_cast<int>(ceilf((rect->y() + rect->height()) * scale));
   rect->SetRect(left, top, right - left, bottom - top);
 }
 
+// TODO(raymes): Remove this dependency on VarPrivate/InstancePrivate. It's
+// needed right now to do a synchronous call to JavaScript, but we could easily
+// replace this with a custom PPB_PDF function.
+pp::Var ModalDialog(const pp::Instance* instance,
+                    const std::string& type,
+                    const std::string& message,
+                    const std::string& default_answer) {
+  const PPB_Instance_Private* interface =

[Lei Zhang, 2014/05/21 01:28:55]

Is it possible to sanely handle the case where the returned ptr is NULL?

+      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);
+}
+
 }  // namespace
 
 OutOfProcessInstance::OutOfProcessInstance(PP_Instance instance)
-    : pp::InstancePrivate(instance),
+    : pp::Instance(instance),
       pp::Find_Private(this),
       pp::Printing_Dev(this),
       pp::Selection_Dev(this),
       cursor_(PP_CURSORTYPE_POINTER),
       zoom_(1.0),
       device_scale_(1.0),
       printing_enabled_(true),
       full_(false),
       paint_manager_(this, this, true),
       first_paint_(true),
@@ skipping 282 matching lines @@
   }
 
   if (image_data_.is_null()) {
     DCHECK(plugin_size_.IsEmpty());
     return;
   }
 
   OnGeometryChanged(zoom_, old_device_scale);
 }
 
-pp::Var OutOfProcessInstance::GetInstanceObject() {
-  return pp::Var();
-}
-
 pp::Var OutOfProcessInstance::GetLinkAtPosition(
     const pp::Point& point) {
   pp::Point offset_point(point);
   ScalePoint(device_scale_, &offset_point);
   offset_point.set_x(offset_point.x() - available_area_.x());
   return engine_->GetLinkAtPosition(offset_point);
 }
 
 pp::Var OutOfProcessInstance::GetSelectedText(bool html) {
   if (html || !engine_->HasPermission(PDFEngine::PERMISSION_COPY))
@@ skipping 286 matching lines @@
       return;
     }
     // Make sure |url_copy| is not only a scheme.
     if (url_copy == "http://" ||
         url_copy == "https://" ||
         url_copy == "ftp://" ||
         url_copy == "mailto:") {
       return;
     }
   }
-  if (open_in_new_tab) {
-    GetWindowObject().Call("open", url_copy);
-  } else {
-    GetWindowObject().GetProperty("top").GetProperty("location").
-        SetProperty("href", url_copy);
-  }
+  pp::VarDictionary message;
+  message.Set(kType, kJSNavigateType);
+  message.Set(kJSNavigateUrl, url_copy);
+  message.Set(kJSNavigateNewTab, open_in_new_tab);
+  PostMessage(message);
 }
 
 void OutOfProcessInstance::UpdateCursor(PP_CursorType_Dev cursor) {
   if (cursor == cursor_)
     return;
   cursor_ = cursor;
 
   const PPB_CursorControl_Dev* cursor_interface =
       reinterpret_cast<const PPB_CursorControl_Dev*>(
       pp::Module::Get()->GetBrowserInterface(PPB_CURSOR_CONTROL_DEV_INTERFACE));
@@ skipping 52 matching lines @@
   }
 
   password_callback_.reset(
       new 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) {
-  GetWindowObject().Call("alert", message);
+  ModalDialog(this, "alert", message, std::string());
 }
 
 bool OutOfProcessInstance::Confirm(const std::string& message) {
-  pp::Var result = GetWindowObject().Call("confirm", message);
+  pp::Var result = ModalDialog(this, "confirm", message, std::string());
   return result.is_bool() ? result.AsBool() : false;
 }
 
 std::string OutOfProcessInstance::Prompt(const std::string& question,
                                          const std::string& default_answer) {
-  pp::Var result = GetWindowObject().Call("prompt", question, default_answer);
+  pp::Var result = ModalDialog(this, "prompt", question, default_answer);
   return result.is_string() ? result.AsString() : std::string();
 }
 
 std::string OutOfProcessInstance::GetURL() {
   return url_;
 }
 
 void OutOfProcessInstance::Email(const std::string& to,
                                  const std::string& cc,
                                  const std::string& bcc,
                                  const std::string& subject,
                                  const std::string& body) {
-  std::string javascript =
-      "var href = 'mailto:" + net::EscapeUrlEncodedData(to, false) +
-      "?cc=" + net::EscapeUrlEncodedData(cc, false) +
-      "&bcc=" + net::EscapeUrlEncodedData(bcc, false) +
-      "&subject=" + net::EscapeUrlEncodedData(subject, false) +
-      "&body=" + net::EscapeUrlEncodedData(body, false) +
-      "';var temp = window.open(href, '_blank', " +
-      "'width=1,height=1');if(temp) temp.close();";
-  ExecuteScript(javascript);
+  pp::VarDictionary message;
+  message.Set(pp::Var(kType), pp::Var(kJSEmailType));
+  message.Set(pp::Var(kJSEmailTo),
+              pp::Var(net::EscapeUrlEncodedData(to, false)));
+  message.Set(pp::Var(kJSEmailCc),
+              pp::Var(net::EscapeUrlEncodedData(cc, false)));
+  message.Set(pp::Var(kJSEmailBcc),
+              pp::Var(net::EscapeUrlEncodedData(bcc, false)));
+  message.Set(pp::Var(kJSEmailSubject),
+              pp::Var(net::EscapeUrlEncodedData(subject, false)));
+  message.Set(pp::Var(kJSEmailBody),
+              pp::Var(net::EscapeUrlEncodedData(body, false)));
+  PostMessage(message);
 }
 
 void OutOfProcessInstance::Print() {
   if (!printing_enabled_ ||
       (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
        !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))) {
     return;
   }
 
   pp::CompletionCallback callback =
@@ skipping 423 matching lines @@
   LoadPreviewUrl(url);
 }
 
 void OutOfProcessInstance::UserMetricsRecordAction(
     const std::string& action) {
   // TODO(raymes): Move this function to PPB_UMA_Private.
   pp::PDF::UserMetricsRecordAction(this, pp::Var(action));
 }
 
 }  // namespace chrome_pdf