[NaCl SDK] Make the SDK examples buildable as a packaged app.

native_client_sdk/src/examples/websocket/websocket.cc

 // 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.
 
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/websocket.h"
@@ skipping 59 matching lines @@
     return false;
   return true;
 }
 
 void WebSocketInstance::Open(const std::string& url) {
   pp::CompletionCallback callback(OnConnectCompletionCallback, this);
   websocket_ = new pp::WebSocket(this);
   if (!websocket_)
     return;
   websocket_->Connect(pp::Var(url), NULL, 0, callback);
-  PostMessage(pp::Var("log:connecting..."));
+  PostMessage(pp::Var("connecting..."));
 }
 
 void WebSocketInstance::Close() {
   if (!IsConnected())
     return;
   pp::CompletionCallback callback(OnCloseCompletionCallback, this);
   websocket_->Close(
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, pp::Var("bye"), callback);
 }
 
 void WebSocketInstance::Send(const std::string& message) {
   if (!IsConnected())
     return;
   websocket_->SendMessage(pp::Var(message));
-  PostMessage(pp::Var(std::string("log:send: ") + message));
+  PostMessage(pp::Var(std::string("send: ") + message));
 }
 
 void WebSocketInstance::Receive() {
   pp::CompletionCallback callback(OnReceiveCompletionCallback, this);
   // |receive_var_| must be valid until |callback| is invoked.
   // Just use a member variable.
   websocket_->ReceiveMessage(&receive_var_, callback);
 }
 
 void WebSocketInstance::OnConnectCompletion(int32_t result) {
   if (result != PP_OK) {
-    PostMessage(pp::Var("alert:connection failed"));
+    PostMessage(pp::Var("connection failed"));
     return;
   }
-  PostMessage(pp::Var("log:connected"));
+  PostMessage(pp::Var("connected"));
   Receive();
 }
 
 void WebSocketInstance::OnCloseCompletion(int32_t result) {
   PostMessage(pp::Var(PP_OK == result ?
-        "log:closed" :
-        "alert:abnormally closed"));
+        "closed" :
+        "abnormally closed"));
 }
 
 void WebSocketInstance::OnReceiveCompletion(int32_t result) {
   if (result == PP_OK) {
     if (receive_var_.is_array_buffer())
-      PostMessage(pp::Var("log: receive: binary data"));
+      PostMessage(pp::Var("receive: binary data"));
     else
-      PostMessage(pp::Var(std::string("log:receive: ") +
+      PostMessage(pp::Var(std::string("receive: ") +
           receive_var_.AsString()));
   }
   Receive();
 }
 
 void WebSocketInstance::OnConnectCompletionCallback(void* user_data,
                                                     int32_t result) {
   WebSocketInstance* instance = static_cast<WebSocketInstance*>(user_data);
   instance->OnConnectCompletion(result);
 }
@@ skipping 23 matching lines @@
 };
 
 
 // Implement the required pp::CreateModule function that creates our specific
 // kind of Module.
 namespace pp {
 Module* CreateModule() {
   return new WebSocketModule();
 }
 }  // namespace pp