Rename Instance_Trusted to Instance_Private, wire it up in Chrome.

ppapi/example/example.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.
 
 #include <math.h>
 #include <stdio.h>  // FIXME(brettw) erase me.
 #ifndef _WIN32
 #include <sys/time.h>
 #endif
 #include <time.h>
 
 #include <algorithm>
 #include <sstream>
 
 #include "ppapi/c/dev/ppb_console_dev.h"
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
 #include "ppapi/c/dev/ppp_printing_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/scriptable_object_deprecated.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
-#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/private/instance_private.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/private/var_private.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/url_loader.h"
 #include "ppapi/cpp/url_request_info.h"
 
 static const int kStepsPerCircle = 800;
 
 void FlushCallback(void* data, int32_t result);
 
 void FillRect(pp::ImageData* image, int left, int top, int width, int height,
               uint32_t color) {
   for (int y = std::max(0, top);
        y < std::min(image->size().height() - 1, top + height);
        y++) {
     for (int x = std::max(0, left);
          x < std::min(image->size().width() - 1, left + width);
          x++)
       *image->GetAddr32(pp::Point(x, y)) = color;
   }
 }
 
 class MyScriptableObject : public pp::deprecated::ScriptableObject {
  public:
-  explicit MyScriptableObject(pp::Instance* instance) : instance_(instance) {}
+  explicit MyScriptableObject(pp::InstancePrivate* instance)
+      : instance_(instance) {}
 
   virtual bool HasMethod(const pp::Var& method, pp::Var* exception) {
     return method.AsString() == "toString";
   }
 
   virtual bool HasProperty(const pp::Var& name, pp::Var* exception) {
     if (name.is_string() && name.AsString() == "blah")
       return true;
     return false;
   }
@@ skipping 11 matching lines @@
 
   virtual pp::Var Call(const pp::Var& method,
                        const std::vector<pp::Var>& args,
                        pp::Var* exception) {
     if (method.AsString() == "toString")
       return pp::Var("hello world");
     return pp::Var();
   }
 
  private:
-  pp::Instance* instance_;
+  pp::InstancePrivate* instance_;
 };
 
 class MyFetcherClient {
  public:
   virtual void DidFetch(bool success, const std::string& data) = 0;
 };
 
 class MyFetcher {
  public:
   MyFetcher() : client_(NULL) {
     callback_factory_.Initialize(this);
   }
 
-  void Start(const pp::Instance& instance,
+  void Start(const pp::InstancePrivate& instance,
              const pp::Var& url,
              MyFetcherClient* client) {
     pp::URLRequestInfo request;
     request.SetURL(url);
     request.SetMethod("GET");
 
     loader_ = pp::URLLoader(instance);
     client_ = client;
 
     pp::CompletionCallback callback =
@@ skipping 42 matching lines @@
       client_->DidFetch(result == PP_OK, data_);
   }
 
   pp::CompletionCallbackFactory<MyFetcher> callback_factory_;
   pp::URLLoader loader_;
   MyFetcherClient* client_;
   char buf_[4096];
   std::string data_;
 };
 
-class MyInstance : public pp::Instance, public MyFetcherClient {
+class MyInstance : public pp::InstancePrivate, public MyFetcherClient {
  public:
   MyInstance(PP_Instance instance)
-      : pp::Instance(instance),
+      : pp::InstancePrivate(instance),
         time_at_last_check_(0.0),
         fetcher_(NULL),
         width_(0),
         height_(0),
         animation_counter_(0),
         print_settings_valid_(false),
         showing_custom_cursor_(false) {}
 
   virtual ~MyInstance() {
     if (fetcher_) {
@@ skipping 300 matching lines @@
 };
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp