Switched events to use native objects instead of wrappers

	Change on 2015/01/02 by mlumish <mlumish@google.com>
-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=83146045

src/php/ext/grpc/call.c

@@ -26,7 +26,7 @@
 /* Frees and destroys an instance of wrapped_grpc_call */
 void free_wrapped_grpc_call(void *object TSRMLS_DC){
   wrapped_grpc_call *call = (wrapped_grpc_call*)object;
-  if(call->wrapped != NULL){
+  if(call->owned && call->wrapped != NULL){
     grpc_call_destroy(call->wrapped);
   }
   efree(call);
@@ -53,7 +53,9 @@ zend_object_value create_wrapped_grpc_call(
   return retval;
 }
 
-zval *grpc_php_wrap_call(grpc_call *wrapped){
+/* Wraps a grpc_call struct in a PHP object. Owned indicates whether the struct
+   should be destroyed at the end of the object's lifecycle */
+zval *grpc_php_wrap_call(grpc_call *wrapped, bool owned){
   zval *call_object;
   MAKE_STD_ZVAL(call_object);
   object_init_ex(call_object, grpc_ce_call);

src/php/ext/grpc/call.h

@@ -19,6 +19,7 @@ zend_class_entry *grpc_ce_call;
 typedef struct wrapped_grpc_call {
   zend_object std;
 
+  bool owned;
   grpc_call *wrapped;
 } wrapped_grpc_call;
 
@@ -26,7 +27,7 @@ typedef struct wrapped_grpc_call {
 void grpc_init_call(TSRMLS_D);
 
 /* Creates a Call object that wraps the given grpc_call struct */
-zval *grpc_php_wrap_call(grpc_call *wrapped);
+zval *grpc_php_wrap_call(grpc_call *wrapped, bool owned);
 
 /* Creates and returns a PHP associative array of metadata from a C array of
  * call metadata */

src/php/ext/grpc/completion_queue.c

@@ -99,7 +99,7 @@ PHP_METHOD(CompletionQueue, next){
   if(event == NULL){
     RETURN_NULL();
   }
-  zval *wrapped_event = grpc_php_wrap_event(event);
+  zval *wrapped_event = grpc_php_convert_event(event);
   RETURN_DESTROY_ZVAL(wrapped_event);
 }
 
@@ -126,7 +126,7 @@ PHP_METHOD(CompletionQueue, pluck){
   if(event == NULL){
     RETURN_NULL();
   }
-  zval *wrapped_event = grpc_php_wrap_event(event);
+  zval *wrapped_event = grpc_php_convert_event(event);
   RETURN_DESTROY_ZVAL(wrapped_event);
 }
 

src/php/ext/grpc/event.c

@@ -17,86 +17,10 @@
 #include "call.h"
 #include "timeval.h"
 
-/* Frees and finishes a wrapped instance of grpc_event */
-void free_wrapped_grpc_event(void *object TSRMLS_DC){
-  wrapped_grpc_event *event = (wrapped_grpc_event*)object;
-  if(event->wrapped != NULL){
-    grpc_event_finish(event->wrapped);
-  }
-  efree(event);
-}
-
-/* Initializes an instance of wrapped_grpc_channel to be associated with an
- * object of a class specified by class_type */
-zend_object_value create_wrapped_grpc_event(
-    zend_class_entry *class_type TSRMLS_DC){
-  zend_object_value retval;
-  wrapped_grpc_event *intern;
-  intern = (wrapped_grpc_event*)emalloc(sizeof(wrapped_grpc_event));
-  memset(intern, 0, sizeof(wrapped_grpc_event));
-  zend_object_std_init(&intern->std, class_type TSRMLS_CC);
-  object_properties_init(&intern->std, class_type);
-  retval.handle = zend_objects_store_put(
-      intern,
-      (zend_objects_store_dtor_t)zend_objects_destroy_object,
-      free_wrapped_grpc_event,
-      NULL TSRMLS_CC);
-  retval.handlers = zend_get_std_object_handlers();
-  return retval;
-}
-
-zval *grpc_php_wrap_event(grpc_event *wrapped){
-  zval *event_object;
-  MAKE_STD_ZVAL(event_object);
-
-  object_init_ex(event_object, grpc_ce_event);
-  wrapped_grpc_event *event = (wrapped_grpc_event*)zend_object_store_get_object(
-      event_object TSRMLS_CC);
-  event->wrapped = wrapped;
-  return event_object;
-}
-
-/**
- * Get the type of the event
- * @return long Integer representing the type
- */
-PHP_METHOD(Event, get_type){
-  wrapped_grpc_event *event = (wrapped_grpc_event*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
-  RETURN_LONG((long)(event->wrapped->type));
-}
-
-/**
- * Get the tag of the event
- * @return long The event's tag
- */
-PHP_METHOD(Event, get_tag){
-  wrapped_grpc_event *event = (wrapped_grpc_event*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
-  RETURN_LONG((long)(event->wrapped->tag));
-}
-
-/**
- * Get the call associated with the event
- * @return Call The call
- */
-PHP_METHOD(Event, get_call){
-  wrapped_grpc_event *event = (wrapped_grpc_event*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
-  zval *call_obj = grpc_php_wrap_call(event->wrapped->call);
-  RETURN_DESTROY_ZVAL(call_obj);
-}
-
-/**
- * Get the data associated with the event
- * @return object The data, with type depending on the type field
- */
-PHP_METHOD(Event, get_data){
-  zval *retval;
-  wrapped_grpc_event *wrapped_event =
-    (wrapped_grpc_event*)zend_object_store_get_object(
-        getThis() TSRMLS_CC);
-  grpc_event *event = wrapped_event->wrapped;
+/* Create a new PHP object containing the event data in the event struct.
+   event must not be used after this function is called */
+zval *grpc_php_convert_event(grpc_event *event) {
+  zval *data_object;
   char *detail_string;
   size_t detail_len;
   char *method_string;
@@ -106,89 +30,103 @@ PHP_METHOD(Event, get_data){
   char *read_string;
   size_t read_len;
 
+  zval *event_object;
+
+  if(event == NULL) {
+    return NULL;
+  }
+
+  MAKE_STD_ZVAL(event_object);
+  object_init(event_object);
+
+  add_property_zval(event_object,
+                    "call",
+                    grpc_php_wrap_call(event->call,
+                                       event->type==GRPC_SERVER_RPC_NEW));
+  add_property_long(event_object, "type", event->type);
+  add_property_long(event_object, "tag", (long)event->tag);
+
   switch(event->type){
-    case GRPC_QUEUE_SHUTDOWN: RETURN_NULL(); break;
+    case GRPC_QUEUE_SHUTDOWN: add_property_null(event_object, "data"); break;
     case GRPC_READ:
       if(event->data.read == NULL){
-        RETURN_NULL();
+        add_property_null(event_object, "data");
       } else {
         byte_buffer_to_string(event->data.read, &read_string, &read_len);
-        RETURN_STRINGL(read_string, read_len, true);
+        add_property_stringl(event_object, "data", read_string, read_len, true);
       }
       break;
     case GRPC_INVOKE_ACCEPTED:
-      RETURN_LONG((long)event->data.invoke_accepted); break;
+      add_property_long(event_object,
+                        "data",
+                        (long)event->data.invoke_accepted);
+      break;
     case GRPC_WRITE_ACCEPTED:
-      RETURN_LONG((long)event->data.write_accepted); break;
+      add_property_long(event_object, "data", (long)event->data.write_accepted);
+      break;
     case GRPC_FINISH_ACCEPTED:
-      RETURN_LONG((long)event->data.finish_accepted); break;
+      add_property_long(event_object,
+                        "data",
+                        (long)event->data.finish_accepted);
+      break;
     case GRPC_CLIENT_METADATA_READ:
-      retval = grpc_call_create_metadata_array(
+      data_object = grpc_call_create_metadata_array(
           event->data.client_metadata_read.count,
           event->data.client_metadata_read.elements);
+      add_property_zval(event_object, "data", data_object);
       break;
     case GRPC_FINISHED:
-      MAKE_STD_ZVAL(retval);
-      object_init(retval);
-      add_property_long(retval, "code", event->data.finished.status);
+      MAKE_STD_ZVAL(data_object);
+      object_init(data_object);
+      add_property_long(data_object, "code", event->data.finished.status);
       if(event->data.finished.details == NULL){
-        add_property_null(retval, "details");
+        add_property_null(data_object, "details");
       } else {
         detail_len = strlen(event->data.finished.details);
         detail_string = ecalloc(detail_len+1, sizeof(char));
         memcpy(detail_string, event->data.finished.details, detail_len);
-        add_property_string(retval,
+        add_property_string(data_object,
                             "details",
                             detail_string,
                             true);
       }
-      add_property_zval(retval, "metadata", grpc_call_create_metadata_array(
-          event->data.finished.metadata_count,
-          event->data.finished.metadata_elements));
+      add_property_zval(data_object,
+                        "metadata",
+                        grpc_call_create_metadata_array(
+                            event->data.finished.metadata_count,
+                            event->data.finished.metadata_elements));
+      add_property_zval(event_object, "data", data_object);
       break;
     case GRPC_SERVER_RPC_NEW:
-      MAKE_STD_ZVAL(retval);
-      object_init(retval);
+      MAKE_STD_ZVAL(data_object);
+      object_init(data_object);
       method_len = strlen(event->data.server_rpc_new.method);
       method_string = ecalloc(method_len+1, sizeof(char));
       memcpy(method_string, event->data.server_rpc_new.method, method_len);
-      add_property_string(retval,
+      add_property_string(data_object,
                           "method",
                           method_string,
                           false);
       host_len = strlen(event->data.server_rpc_new.host);
       host_string = ecalloc(host_len+1, sizeof(char));
       memcpy(host_string, event->data.server_rpc_new.host, host_len);
-      add_property_string(retval,
+      add_property_string(data_object,
                           "host",
                           host_string,
                           false);
-      add_property_zval(retval,
+      add_property_zval(data_object,
                         "absolute_timeout",
                         grpc_php_wrap_timeval(
                             event->data.server_rpc_new.deadline));
-      add_property_zval(retval,
+      add_property_zval(data_object,
                         "metadata",
                         grpc_call_create_metadata_array(
                             event->data.server_rpc_new.metadata_count,
                             event->data.server_rpc_new.metadata_elements));
+      add_property_zval(event_object, "data", data_object);
       break;
-    default: RETURN_NULL(); break;
+    default: add_property_null(event_object, "data"); break;
   }
-  RETURN_DESTROY_ZVAL(retval);
-}
-
-static zend_function_entry event_methods[] = {
-  PHP_ME(Event, get_call, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Event, get_data, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Event, get_tag, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Event, get_type, NULL, ZEND_ACC_PUBLIC)
-  PHP_FE_END
-};
-
-void grpc_init_event(TSRMLS_D){
-  zend_class_entry ce;
-  INIT_CLASS_ENTRY(ce, "Grpc\\Event", event_methods);
-  ce.create_object = create_wrapped_grpc_event;
-  grpc_ce_event = zend_register_internal_class(&ce TSRMLS_CC);
+  grpc_event_finish(event);
+  return event_object;
 }

src/php/ext/grpc/event.h

@@ -12,20 +12,7 @@
 
 #include "grpc/grpc.h"
 
-/* Class entry for the PHP Event class */
-zend_class_entry *grpc_ce_event;
-
-/* Struct wrapping grpc_event that can be associated with a PHP object */
-typedef struct wrapped_grpc_event {
-  zend_object std;
-
-  grpc_event *wrapped;
-} wrapped_grpc_event;
-
-/* Initialize the Event class */
-void grpc_init_event(TSRMLS_D);
-
 /* Create a new Event object that wraps an existing grpc_event struct */
-zval *grpc_php_wrap_event(grpc_event *wrapped);
+zval *grpc_php_convert_event(grpc_event *event);
 
 #endif /* NET_GRPC_PHP_GRPC_COMPLETION_CHANNEL_H */

src/php/ext/grpc/php_grpc.c

@@ -196,7 +196,6 @@ PHP_MINIT_FUNCTION(grpc)
     grpc_init_channel(TSRMLS_C);
     grpc_init_server(TSRMLS_C);
     grpc_init_completion_queue(TSRMLS_C);
-    grpc_init_event(TSRMLS_C);
     grpc_init_timeval(TSRMLS_C);
     grpc_init_credentials(TSRMLS_C);
     grpc_init_server_credentials(TSRMLS_C);

src/php/lib/Grpc/ActiveCall.php

@@ -35,7 +35,7 @@ class ActiveCall {
                                    Timeval::inf_future());
     $metadata_event = $this->completion_queue->pluck(CLIENT_METADATA_READ,
                                                      Timeval::inf_future());
-    $this->metadata = $metadata_event->get_data();
+    $this->metadata = $metadata_event->data;
   }
 
   /**
@@ -59,7 +59,7 @@ class ActiveCall {
   public function read() {
     $this->call->start_read(READ);
     $read_event = $this->completion_queue->pluck(READ, Timeval::inf_future());
-    return $read_event->get_data();
+    return $read_event->data;
   }
 
   /**
@@ -93,6 +93,6 @@ class ActiveCall {
   public function getStatus() {
     $status_event = $this->completion_queue->pluck(FINISHED,
                                                    Timeval::inf_future());
-    return $status_event->get_data();
+    return $status_event->data;
   }
 }

src/php/tests/unit_tests/EndToEndTest.php

@@ -35,21 +35,21 @@ class EndToEndTest extends PHPUnit_Framework_TestCase{
     // the client invocation was accepted
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\INVOKE_ACCEPTED, $event->get_type());
+    $this->assertEquals(Grpc\INVOKE_ACCEPTED, $event->type);
 
     $this->assertEquals(Grpc\CALL_OK, $call->writes_done($tag));
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->get_type());
-    $this->assertEquals(Grpc\OP_OK, $event->get_data());
+    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->type);
+    $this->assertEquals(Grpc\OP_OK, $event->data);
 
     // check that a server rpc new was received
     $this->server->start();
     $this->assertEquals(Grpc\CALL_OK, $this->server->request_call($server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\SERVER_RPC_NEW, $event->get_type());
-    $server_call = $event->get_call();
+    $this->assertEquals(Grpc\SERVER_RPC_NEW, $event->type);
+    $server_call = $event->call;
     $this->assertNotNull($server_call);
     $this->assertEquals(Grpc\CALL_OK,
                         $server_call->server_accept($this->server_queue,
@@ -66,27 +66,27 @@ class EndToEndTest extends PHPUnit_Framework_TestCase{
                                                          $server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->get_type());
-    $this->assertEquals(Grpc\OP_OK, $event->get_data());
+    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->type);
+    $this->assertEquals(Grpc\OP_OK, $event->data);
 
     // the client gets CLIENT_METADATA_READ
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\CLIENT_METADATA_READ, $event->get_type());
+    $this->assertEquals(Grpc\CLIENT_METADATA_READ, $event->type);
 
     // the client gets FINISHED
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISHED, $event->get_type());
-    $status = $event->get_data();
+    $this->assertEquals(Grpc\FINISHED, $event->type);
+    $status = $event->data;
     $this->assertEquals(Grpc\STATUS_OK, $status->code);
     $this->assertEquals($status_text, $status->details);
 
     // and the server gets FINISHED
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISHED, $event->get_type());
-    $status = $event->get_data();
+    $this->assertEquals(Grpc\FINISHED, $event->type);
+    $status = $event->data;
 
     unset($call);
     unset($server_call);
@@ -113,21 +113,21 @@ class EndToEndTest extends PHPUnit_Framework_TestCase{
     // the client invocation was accepted
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\INVOKE_ACCEPTED, $event->get_type());
+    $this->assertEquals(Grpc\INVOKE_ACCEPTED, $event->type);
 
     // the client writes
     $this->assertEquals(Grpc\CALL_OK, $call->start_write($req_text, $tag));
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\WRITE_ACCEPTED, $event->get_type());
+    $this->assertEquals(Grpc\WRITE_ACCEPTED, $event->type);
 
     // check that a server rpc new was received
     $this->server->start();
     $this->assertEquals(Grpc\CALL_OK, $this->server->request_call($server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\SERVER_RPC_NEW, $event->get_type());
-    $server_call = $event->get_call();
+    $this->assertEquals(Grpc\SERVER_RPC_NEW, $event->type);
+    $server_call = $event->call;
     $this->assertNotNull($server_call);
     $this->assertEquals(Grpc\CALL_OK,
                         $server_call->server_accept($this->server_queue,
@@ -140,33 +140,33 @@ class EndToEndTest extends PHPUnit_Framework_TestCase{
     $this->assertEquals(Grpc\CALL_OK, $server_call->start_read($server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\READ, $event->get_type());
-    $this->assertEquals($req_text, $event->get_data());
+    $this->assertEquals(Grpc\READ, $event->type);
+    $this->assertEquals($req_text, $event->data);
 
     // the server replies
     $this->assertEquals(Grpc\CALL_OK,
                         $server_call->start_write($reply_text, $server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\WRITE_ACCEPTED, $event->get_type());
+    $this->assertEquals(Grpc\WRITE_ACCEPTED, $event->type);
 
     // the client reads the metadata
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\CLIENT_METADATA_READ, $event->get_type());
+    $this->assertEquals(Grpc\CLIENT_METADATA_READ, $event->type);
 
     // the client reads the reply
     $this->assertEquals(Grpc\CALL_OK, $call->start_read($tag));
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\READ, $event->get_type());
-    $this->assertEquals($reply_text, $event->get_data());
+    $this->assertEquals(Grpc\READ, $event->type);
+    $this->assertEquals($reply_text, $event->data);
 
     // the client sends writes done
     $this->assertEquals(Grpc\CALL_OK, $call->writes_done($tag));
     $event = $this->client_queue->next($deadline);
-    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->get_type());
-    $this->assertEquals(Grpc\OP_OK, $event->get_data());
+    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->type);
+    $this->assertEquals(Grpc\OP_OK, $event->data);
 
     // the server sends the status
     $this->assertEquals(Grpc\CALL_OK,
@@ -174,21 +174,21 @@ class EndToEndTest extends PHPUnit_Framework_TestCase{
                                                          $status_text,
                                                          $server_tag));
     $event = $this->server_queue->next($deadline);
-    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->get_type());
-    $this->assertEquals(Grpc\OP_OK, $event->get_data());
+    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->type);
+    $this->assertEquals(Grpc\OP_OK, $event->data);
 
     // the client gets FINISHED
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISHED, $event->get_type());
-    $status = $event->get_data();
+    $this->assertEquals(Grpc\FINISHED, $event->type);
+    $status = $event->data;
     $this->assertEquals(Grpc\STATUS_OK, $status->code);
     $this->assertEquals($status_text, $status->details);
 
     // and the server gets FINISHED
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISHED, $event->get_type());
+    $this->assertEquals(Grpc\FINISHED, $event->type);
 
     unset($call);
     unset($server_call);

src/php/tests/unit_tests/SecureEndToEndTest.php

@@ -46,20 +46,20 @@ class SecureEndToEndTest extends PHPUnit_Framework_TestCase{
     // the client invocation was accepted
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\INVOKE_ACCEPTED, $event->get_type());
+    $this->assertEquals(Grpc\INVOKE_ACCEPTED, $event->type);
 
     $this->assertEquals(Grpc\CALL_OK, $call->writes_done($tag));
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->get_type());
-    $this->assertEquals(Grpc\OP_OK, $event->get_data());
+    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->type);
+    $this->assertEquals(Grpc\OP_OK, $event->data);
 
     // check that a server rpc new was received
     $this->assertEquals(Grpc\CALL_OK, $this->server->request_call($server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\SERVER_RPC_NEW, $event->get_type());
-    $server_call = $event->get_call();
+    $this->assertEquals(Grpc\SERVER_RPC_NEW, $event->type);
+    $server_call = $event->call;
     $this->assertNotNull($server_call);
     $this->assertEquals(Grpc\CALL_OK,
                         $server_call->server_accept($this->server_queue,
@@ -75,27 +75,27 @@ class SecureEndToEndTest extends PHPUnit_Framework_TestCase{
                                                          $server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->get_type());
-    $this->assertEquals(Grpc\OP_OK, $event->get_data());
+    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->type);
+    $this->assertEquals(Grpc\OP_OK, $event->data);
 
     // the client gets CLIENT_METADATA_READ
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\CLIENT_METADATA_READ, $event->get_type());
+    $this->assertEquals(Grpc\CLIENT_METADATA_READ, $event->type);
 
     // the client gets FINISHED
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISHED, $event->get_type());
-    $status = $event->get_data();
+    $this->assertEquals(Grpc\FINISHED, $event->type);
+    $status = $event->data;
     $this->assertEquals(Grpc\STATUS_OK, $status->code);
     $this->assertEquals($status_text, $status->details);
 
     // and the server gets FINISHED
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISHED, $event->get_type());
-    $status = $event->get_data();
+    $this->assertEquals(Grpc\FINISHED, $event->type);
+    $status = $event->data;
 
     unset($call);
     unset($server_call);
@@ -123,20 +123,20 @@ class SecureEndToEndTest extends PHPUnit_Framework_TestCase{
     // the client invocation was accepted
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\INVOKE_ACCEPTED, $event->get_type());
+    $this->assertEquals(Grpc\INVOKE_ACCEPTED, $event->type);
 
     // the client writes
     $this->assertEquals(Grpc\CALL_OK, $call->start_write($req_text, $tag));
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\WRITE_ACCEPTED, $event->get_type());
+    $this->assertEquals(Grpc\WRITE_ACCEPTED, $event->type);
 
     // check that a server rpc new was received
     $this->assertEquals(Grpc\CALL_OK, $this->server->request_call($server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\SERVER_RPC_NEW, $event->get_type());
-    $server_call = $event->get_call();
+    $this->assertEquals(Grpc\SERVER_RPC_NEW, $event->type);
+    $server_call = $event->call;
     $this->assertNotNull($server_call);
     $this->assertEquals(Grpc\CALL_OK,
                         $server_call->server_accept($this->server_queue,
@@ -149,33 +149,33 @@ class SecureEndToEndTest extends PHPUnit_Framework_TestCase{
     $this->assertEquals(Grpc\CALL_OK, $server_call->start_read($server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\READ, $event->get_type());
-    $this->assertEquals($req_text, $event->get_data());
+    $this->assertEquals(Grpc\READ, $event->type);
+    $this->assertEquals($req_text, $event->data);
 
     // the server replies
     $this->assertEquals(Grpc\CALL_OK,
                         $server_call->start_write($reply_text, $server_tag));
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\WRITE_ACCEPTED, $event->get_type());
+    $this->assertEquals(Grpc\WRITE_ACCEPTED, $event->type);
 
     // the client reads the metadata
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\CLIENT_METADATA_READ, $event->get_type());
+    $this->assertEquals(Grpc\CLIENT_METADATA_READ, $event->type);
 
     // the client reads the reply
     $this->assertEquals(Grpc\CALL_OK, $call->start_read($tag));
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\READ, $event->get_type());
-    $this->assertEquals($reply_text, $event->get_data());
+    $this->assertEquals(Grpc\READ, $event->type);
+    $this->assertEquals($reply_text, $event->data);
 
     // the client sends writes done
     $this->assertEquals(Grpc\CALL_OK, $call->writes_done($tag));
     $event = $this->client_queue->next($deadline);
-    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->get_type());
-    $this->assertEquals(Grpc\OP_OK, $event->get_data());
+    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->type);
+    $this->assertEquals(Grpc\OP_OK, $event->data);
 
     // the server sends the status
     $this->assertEquals(Grpc\CALL_OK,
@@ -183,21 +183,21 @@ class SecureEndToEndTest extends PHPUnit_Framework_TestCase{
                                                          $status_text,
                                                          $server_tag));
     $event = $this->server_queue->next($deadline);
-    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->get_type());
-    $this->assertEquals(Grpc\OP_OK, $event->get_data());
+    $this->assertEquals(Grpc\FINISH_ACCEPTED, $event->type);
+    $this->assertEquals(Grpc\OP_OK, $event->data);
 
     // the client gets FINISHED
     $event = $this->client_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISHED, $event->get_type());
-    $status = $event->get_data();
+    $this->assertEquals(Grpc\FINISHED, $event->type);
+    $status = $event->data;
     $this->assertEquals(Grpc\STATUS_OK, $status->code);
     $this->assertEquals($status_text, $status->details);
 
     // and the server gets FINISHED
     $event = $this->server_queue->next($deadline);
     $this->assertNotNull($event);
-    $this->assertEquals(Grpc\FINISHED, $event->get_type());
+    $this->assertEquals(Grpc\FINISHED, $event->type);
 
     unset($call);
     unset($server_call);