Convert resources to take an instance key instead of an Instance*.

ppapi/utility/threading/simple_thread.h

 // 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.
 
 #ifndef PPAPI_UTILITY_THREADING_SIMPLE_THREAD_H_
 #define PPAPI_UTILITY_THREADING_SIMPLE_THREAD_H_
 
 #ifdef WIN32
 #include <windows.h>
 #else
 #include <pthread.h>
 #endif
 
 #include "ppapi/cpp/dev/message_loop_dev.h"
+#include "ppapi/cpp/instance_handle.h"
 
 namespace pp {
 
 // This class is a simple wrapper around a pthread/Windows thread that creates
 // and runs a PPAPI message loop on that thread.
 class SimpleThread {
  public:
 #ifdef WIN32
   typedef HANDLE ThreadHandle;
 #else
   typedef pthread_t ThreadHandle;
 #endif
 
   typedef void (*ThreadFunc)(MessageLoop_Dev&, void* user_data);
 
-  SimpleThread(Instance* instance);
+  SimpleThread(const InstanceHandle& instance);

[dmichael (off chromium), 2012/02/21 23:38:02]

explicit

   ~SimpleThread();
 
   // Starts a thread and runs a message loop in it. If you need control over
   // how the message loop is run, use StartWithFunction. Returns true on
   // success, false if the thread is already running or couldn't be started.
   bool Start();
 
   // Posts a quit message to the message loop and blocks until the thread
   // exits. Returns true on success. If the thread is not running, returns
   // false.
   bool Join();
 
   // Normally you can just use Start() to start a thread, and then post work to
   // it. In some cases you will want control over the message. If ThreadFunc
   // is NULL, this acts the same as Start().
   bool StartWithFunction(ThreadFunc func, void* user_data);
 
   MessageLoop_Dev& message_loop() { return message_loop_; }
   ThreadHandle thread() const { return thread_; }
 
  private:
-  Instance* instance_;
+  InstanceHandle instance_;
   MessageLoop_Dev message_loop_;
 
   ThreadHandle thread_;
 
   // Disallow (not implemented).
   SimpleThread(const SimpleThread&);
   SimpleThread& operator=(const SimpleThread&);
 };
 
 }  // namespace pp
 
 #endif  // PPAPI_UTILITY_THREADING_SIMPLE_THREAD_H_