Change the DidChangeView update to take a new ViewChanged resource.

ppapi/native_client/src/trusted/plugin/plugin.cc

 // Copyright (c) 2011 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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "native_client/src/trusted/plugin/plugin.h"
@@ skipping 981 matching lines @@
       argc_(-1),
       argn_(NULL),
       argv_(NULL),
       main_subprocess_(kMainSubprocessId, NULL, NULL),
       nacl_ready_state_(UNSENT),
       nexe_error_reported_(false),
       wrapper_factory_(NULL),
       last_error_string_(""),
       ppapi_proxy_(NULL),
       enable_dev_interfaces_(false),
-      replayDidChangeView(false),
-      replayHandleDocumentLoad(false),
       init_time_(0),
       ready_time_(0),
       nexe_size_(0),
       time_of_last_progress_event_(0) {
   PLUGIN_PRINTF(("Plugin::Plugin (this=%p, pp_instance=%"
                  NACL_PRId32")\n", static_cast<void*>(this), pp_instance));
   callback_factory_.Initialize(this);
   nexe_downloader_.Initialize(this);
 }
 
@@ skipping 57 matching lines @@
   HistogramTimeSmall(
       "NaCl.Perf.ShutdownTime.Total",
       (NaClGetTimeOfDayMicroseconds() - shutdown_start)
           / NACL_MICROS_PER_MILLI);
 
   PLUGIN_PRINTF(("Plugin::~Plugin (this=%p, return)\n",
                  static_cast<void*>(this)));
 }
 
 
-void Plugin::DidChangeView(const pp::Rect& position, const pp::Rect& clip) {
+void Plugin::DidChangeView(const pp::View& view) {
   PLUGIN_PRINTF(("Plugin::DidChangeView (this=%p)\n",
                  static_cast<void*>(this)));
 
   if (!BrowserPpp::is_valid(ppapi_proxy_)) {
     // Store this event and replay it when the proxy becomes available.
-    replayDidChangeView = true;
-    replayDidChangeViewPosition = position;
-    replayDidChangeViewClip = clip;
-    return;
+    view_to_replay_ = view;
   } else {
     ppapi_proxy_->ppp_instance_interface()->DidChangeView(
-        pp_instance(), &(position.pp_rect()), &(clip.pp_rect()));
+        pp_instance(), view.pp_resource());
   }
 }
 
 
 void Plugin::DidChangeFocus(bool has_focus) {
   PLUGIN_PRINTF(("Plugin::DidChangeFocus (this=%p)\n",
                  static_cast<void*>(this)));
-  if (!BrowserPpp::is_valid(ppapi_proxy_)) {
-    return;
-  } else {
+  if (BrowserPpp::is_valid(ppapi_proxy_)) {
     ppapi_proxy_->ppp_instance_interface()->DidChangeFocus(
         pp_instance(), PP_FromBool(has_focus));
   }
 }
 
 
 bool Plugin::HandleInputEvent(const pp::InputEvent& event) {
   PLUGIN_PRINTF(("Plugin::HandleInputEvent (this=%p)\n",
                  static_cast<void*>(this)));
   if (!BrowserPpp::is_valid(ppapi_proxy_) ||
       ppapi_proxy_->ppp_input_event_interface() == NULL) {
     return false;  // event is not handled here.
   } else {
     bool handled = PP_ToBool(
         ppapi_proxy_->ppp_input_event_interface()->HandleInputEvent(
             pp_instance(), event.pp_resource()));
     PLUGIN_PRINTF(("Plugin::HandleInputEvent (handled=%d)\n", handled));
     return handled;
   }
 }
 
 
 bool Plugin::HandleDocumentLoad(const pp::URLLoader& url_loader) {
   PLUGIN_PRINTF(("Plugin::HandleDocumentLoad (this=%p)\n",
                  static_cast<void*>(this)));
   if (!BrowserPpp::is_valid(ppapi_proxy_)) {
     // Store this event and replay it when the proxy becomes available.
-    replayHandleDocumentLoad = true;
-    replayHandleDocumentLoadURLLoader = url_loader;
+    document_load_to_replay_ = url_loader;
     // Return true so that the browser keeps servicing this loader so we can
     // perform requests on it later.
     return true;
   } else {
     return PP_ToBool(
         ppapi_proxy_->ppp_instance_interface()->HandleDocumentLoad(
             pp_instance(), url_loader.pp_resource()));
   }
 }
 
@@ skipping 232 matching lines @@
     error_info->SetReport(ERROR_START_PROXY_ALLOC,
                           "could not allocate proxy memory.");
     return false;
   }
   pp::Module* module = pp::Module::Get();
   PLUGIN_PRINTF(("Plugin::StartProxiedExecution (module=%p)\n",
                  static_cast<void*>(module)));
   CHECK(module != NULL);  // We could not have gotten past init stage otherwise.
   int32_t pp_error =
       ppapi_proxy->InitializeModule(module->pp_module(),
-                                     module->get_browser_interface());
+                                    module->get_browser_interface());
   PLUGIN_PRINTF(("Plugin::StartProxiedExecution (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     error_info->SetReport(ERROR_START_PROXY_MODULE,
                           "could not initialize module.");
     return false;
   }
   const PPP_Instance* instance_interface =
       ppapi_proxy->ppp_instance_interface();
   PLUGIN_PRINTF(("Plugin::StartProxiedExecution (ppp_instance=%p)\n",
@@ skipping 16 matching lines @@
 
   // Create PPP* interface adapters to forward calls to .nexe.
   find_adapter_.reset(new(std::nothrow) FindAdapter(this));
   mouse_lock_adapter_.reset(new(std::nothrow) MouseLockAdapter(this));
   printing_adapter_.reset(new(std::nothrow) PrintingAdapter(this));
   selection_adapter_.reset(new(std::nothrow) SelectionAdapter(this));
   widget_client_adapter_.reset(new(std::nothrow) WidgetClientAdapter(this));
   zoom_adapter_.reset(new(std::nothrow) ZoomAdapter(this));
 
   // Replay missed events.
-  if (replayDidChangeView) {
-    replayDidChangeView = false;
-    DidChangeView(replayDidChangeViewPosition, replayDidChangeViewClip);
+  if (!view_to_replay_.is_null()) {
+    DidChangeView(view_to_replay_);
+    view_to_replay_ = pp::View();
   }
-  if (replayHandleDocumentLoad) {
-    replayHandleDocumentLoad = false;
-    HandleDocumentLoad(replayHandleDocumentLoadURLLoader);
-    // Release our reference on this loader.
-    replayHandleDocumentLoadURLLoader = pp::URLLoader();
+  if (!document_load_to_replay_.is_null()) {
+    HandleDocumentLoad(document_load_to_replay_);
+    document_load_to_replay_ = pp::URLLoader();
   }
   bool is_valid_proxy = BrowserPpp::is_valid(ppapi_proxy_);
   PLUGIN_PRINTF(("Plugin::StartProxiedExecution (is_valid_proxy=%d)\n",
                  is_valid_proxy));
   if (!is_valid_proxy) {
     error_info->SetReport(ERROR_START_PROXY_CRASH,
                           "instance crashed after creation.");
   }
   return is_valid_proxy;
 }
@@ skipping 616 matching lines @@
   std::string scheme = canonicalized.AsString().substr(comps.scheme.begin,
                                                        comps.scheme.len);
   if (scheme == kChromeExtensionUriScheme)
     return SCHEME_CHROME_EXTENSION;
   if (scheme == kDataUriScheme)
     return SCHEME_DATA;
   return SCHEME_OTHER;
 }
 
 }  // namespace plugin