Update voronoi demo to use dictionary messages.

native_client_sdk/src/examples/demo/voronoi/voronoi.cc

 // Copyright (c) 2013 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 <assert.h>
 #include <math.h>
 #include <ppapi/cpp/completion_callback.h>
 #include <ppapi/cpp/graphics_2d.h>
 #include <ppapi/cpp/image_data.h>
 #include <ppapi/cpp/input_event.h>
 #include <ppapi/cpp/instance.h>
 #include <ppapi/cpp/module.h>
 #include <ppapi/cpp/rect.h>
 #include <ppapi/cpp/size.h>
 #include <ppapi/cpp/var.h>
+#include <ppapi/cpp/var_dictionary.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <string>
 
@@ skipping 100 matching lines @@
   void SuperimposePositions();
   void Render();
   void Draw();
   void StartBenchmark();
   void EndBenchmark();
 
   // Runs a tick of the simulations, updating all buffers.  Flushes the
   // contents of |image_data_| to the 2D graphics context.
   void Update();
 
+  // Helper to post small update messages to JS.
+  void PostUpdateMessage(const char* message_name, double value);
   // Create and initialize the 2D context used for drawing.
   void CreateContext(const pp::Size& size);
   // Destroy the 2D drawing context.
   void DestroyContext();
   // Push the pixels to the browser, then attempt to flush the 2D context.
   void FlushPixelBuffer();
   static void FlushCallback(void* data, int32_t result);
 
 
   pp::Graphics2D* graphics_2d_context_;
@@ skipping 313 matching lines @@
   benchmarking_ = true;
   benchmark_start_time_ = getseconds();
 }
 
 void Voronoi::EndBenchmark() {
   benchmark_end_time_ = getseconds();
   printf("Benchmark ended... time: %2.5f\n",
       benchmark_end_time_ - benchmark_start_time_);
   benchmarking_ = false;
   benchmark_frame_counter_ = 0;
-  pp::Var result(benchmark_end_time_ - benchmark_start_time_);
-  PostMessage(result);
+  double result = benchmark_end_time_ - benchmark_start_time_;
+  PostUpdateMessage("benchmark_result", result);
 }
 
 // Handle input events from the user.
 bool Voronoi::HandleInputEvent(const pp::InputEvent& event) {
   switch (event.GetType()) {
     case PP_INPUTEVENT_TYPE_KEYDOWN: {
       pp::KeyboardInputEvent key = pp::KeyboardInputEvent(event);
       uint32_t key_code = key.GetKeyCode();
       if (key_code == 84)  // 't' key
         if (!benchmarking_)
           StartBenchmark();
       break;
     }
     default:
       return false;
   }
   return true;
 }
 
 // Handle messages sent from Javascript.
-void Voronoi::HandleMessage(const pp::Var& message) {
-  if (message.is_string()) {
-    std::string message_string = message.AsString();
-    if (message_string == "run benchmark" && !benchmarking_)
+void Voronoi::HandleMessage(const pp::Var& var) {
+  if (var.is_dictionary()) {
+    pp::VarDictionary dictionary = pp::VarDictionary(var);
+    std::string message = dictionary.Get("message").AsString();
+    if (message == "run_benchmark" && !benchmarking_)
       StartBenchmark();
-    else if (message_string == "with points")
-      draw_points_ = true;
-    else if (message_string == "without points")
-      draw_points_ = false;
-    else if (message_string == "with interiors")
-      draw_interiors_ = true;
-    else if (message_string == "without interiors")
-      draw_interiors_ = false;
-    else if (strstr(message_string.c_str(), "points:")) {
-      int num_points = atoi(strstr(message_string.c_str(), " "));
+    else if (message == "draw_points")
+      draw_points_ = dictionary.Get(pp::Var("value")).AsBool();
+    else if (message == "draw_interiors")
+      draw_interiors_ = dictionary.Get(pp::Var("value")).AsBool();
+    else if (message == "set_points") {
+      int num_points = dictionary.Get(pp::Var("value")).AsInt();
       point_count_ = std::min(kMaxPointCount, std::max(0, num_points));
-    } else if (strstr(message_string.c_str(), "threads:")) {
-      int thread_count = atoi(strstr(message_string.c_str(), " "));
+    } else if (message == "set_threads") {
+      int thread_count = dictionary.Get(pp::Var("value")).AsInt();
       delete workers_;
       workers_ = new ThreadPool(thread_count);
     }
   }
 }
 
+// PostUpdateMessage() helper function for sendimg small messages to JS.
+void Voronoi::PostUpdateMessage(const char* message_name, double value) {
+  pp::VarDictionary message;
+  message.Set(pp::Var("message"), pp::Var(message_name));
+  message.Set(pp::Var("value"), pp::Var(value));
+  PostMessage(message);
+}
+
 void Voronoi::FlushCallback(void* thiz, int32_t result) {
   static_cast<Voronoi*>(thiz)->Update();
 }
 
 // Update the 2d region and flush to make it visible on the page.
 void Voronoi::FlushPixelBuffer() {
   graphics_2d_context_->PaintImageData(*image_data_, pp::Point(0, 0));
   graphics_2d_context_->Flush(pp::CompletionCallback(&FlushCallback, this));
 }
 
@@ skipping 48 matching lines @@
     return new Voronoi(instance);
   }
 };
 
 namespace pp {
 Module* CreateModule() {
   return new VoronoiModule();
 }
 }  // namespace pp