Remove keep-alive impulse IPCs from NaCl modules.

ppapi/thunk/enter.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_THUNK_ENTER_H_
 #define PPAPI_THUNK_ENTER_H_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 130 matching lines @@
                                 void* object,
                                 bool report_error);
 
   // Same as SetStateForResourceError except for function API.
   void SetStateForFunctionError(PP_Instance pp_instance,
                                 void* object,
                                 bool report_error);
 
   // For Enter objects that need a resource, we'll store a pointer to the
   // Resource object so that we don't need to look it up more than once. For
-  // Enter objects with no resource, this will be NULL.
-  Resource* resource_;
+  // Enter objects with no resource, this will be null.
+  Resource* resource_ = nullptr;
 
  private:
   bool CallbackIsValid() const;
 
   // Checks whether the callback is valid (i.e., if it is either non-blocking,
   // or blocking and we're on a background thread). If the callback is invalid,
   // this will set retval_ = PP_ERROR_BLOCKS_MAIN_THREAD, and if report_error is
   // set, it will log a message to the programmer.
   void SetStateForCallbackError(bool report_error);
 
   // Holds the callback. For Enter objects that aren't given a callback, this
-  // will be NULL.
+  // will be null.
   scoped_refptr<TrackedCallback> callback_;
 
-  int32_t retval_;
+  int32_t retval_ = PP_OK;
 };
 
 }  // namespace subtle
 
 // EnterResource ---------------------------------------------------------------
 
 template<typename ResourceT, bool lock_on_entry = true>
 class EnterResource
     : public subtle::LockOnEntry<lock_on_entry>,  // Must be first; see above.
       public subtle::EnterBase {
@@ skipping 10 matching lines @@
   ~EnterResource() {}
 
   ResourceT* object() { return object_; }
   Resource* resource() { return resource_; }
 
  private:
   void Init(PP_Resource resource, bool report_error) {
     if (resource_)
       object_ = resource_->GetAs<ResourceT>();
     else
-      object_ = NULL;
+      object_ = nullptr;
     // Validate the resource (note, if both are wrong, we will return
     // PP_ERROR_BADRESOURCE; last in wins).
     SetStateForResourceError(resource, resource_, object_, report_error);
   }
 
   ResourceT* object_;
 
   DISALLOW_COPY_AND_ASSIGN(EnterResource);
 };
 
@@ skipping 49 matching lines @@
 };
 
 // EnterInstanceAPI ------------------------------------------------------------
 
 template<typename ApiT, bool lock_on_entry = true>
 class EnterInstanceAPI
     : public subtle::LockOnEntry<lock_on_entry>,  // Must be first; see above
       public subtle::EnterBase {
  public:
   explicit EnterInstanceAPI(PP_Instance instance)
-      : EnterBase(instance, ApiT::kSingletonResourceID),
-        functions_(NULL) {
+      : EnterBase(instance, ApiT::kSingletonResourceID) {
     if (resource_)
       functions_ = resource_->GetAs<ApiT>();
     SetStateForFunctionError(instance, functions_, true);
   }
-  EnterInstanceAPI(PP_Instance instance,
-                   const PP_CompletionCallback& callback)
-      : EnterBase(instance, ApiT::kSingletonResourceID, callback),
-        functions_(NULL) {
+  EnterInstanceAPI(PP_Instance instance, const PP_CompletionCallback& callback)
+      : EnterBase(instance, ApiT::kSingletonResourceID, callback) {
     if (resource_)
       functions_ = resource_->GetAs<ApiT>();
     SetStateForFunctionError(instance, functions_, true);
   }
   ~EnterInstanceAPI() {}
 
   bool succeeded() const { return !!functions_; }
   bool failed() const { return !functions_; }
 
   ApiT* functions() const { return functions_; }
 
  private:
-  ApiT* functions_;
+  ApiT* functions_ = nullptr;
 };
 
 template<typename ApiT>
 class EnterInstanceAPINoLock : public EnterInstanceAPI<ApiT, false> {
  public:
   explicit EnterInstanceAPINoLock(PP_Instance instance)
       : EnterInstanceAPI<ApiT, false>(instance) {
   }
 };
 
@@ skipping 22 matching lines @@
   ResourceCreationAPI* functions() { return functions_; }
 
  private:
   ResourceCreationAPI* functions_;
 };
 
 }  // namespace thunk
 }  // namespace ppapi
 
 #endif  // PPAPI_THUNK_ENTER_H_