Remove usage of to-be-deprecated APIs from samples

samples/process.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 75 matching lines @@
 };
 
 
 /**
  * An http request processor that is scriptable using JavaScript.
  */
 class JsHttpRequestProcessor : public HttpRequestProcessor {
  public:
   // Creates a new processor that processes requests by invoking the
   // Process function of the JavaScript script given as an argument.
-  JsHttpRequestProcessor(Isolate* isolate, Handle<String> script)
-      : isolate_(isolate), script_(script) { }
+  JsHttpRequestProcessor(Isolate* isolate, Local<String> script)
+      : isolate_(isolate), script_(script) {}
   virtual ~JsHttpRequestProcessor();
 
   virtual bool Initialize(map<string, string>* opts,
                           map<string, string>* output);
   virtual bool Process(HttpRequest* req);
 
  private:
   // Execute the script associated with this processor and extract the
   // Process function.  Returns true if this succeeded, otherwise false.
-  bool ExecuteScript(Handle<String> script);
+  bool ExecuteScript(Local<String> script);
 
   // Wrap the options and output map in a JavaScript objects and
   // install it in the global namespace as 'options' and 'output'.
   bool InstallMaps(map<string, string>* opts, map<string, string>* output);
 
   // Constructs the template that describes the JavaScript wrapper
   // type for requests.
-  static Handle<ObjectTemplate> MakeRequestTemplate(Isolate* isolate);
-  static Handle<ObjectTemplate> MakeMapTemplate(Isolate* isolate);
+  static Local<ObjectTemplate> MakeRequestTemplate(Isolate* isolate);
+  static Local<ObjectTemplate> MakeMapTemplate(Isolate* isolate);
 
   // Callbacks that access the individual fields of request objects.
   static void GetPath(Local<String> name,
                       const PropertyCallbackInfo<Value>& info);
   static void GetReferrer(Local<String> name,
                           const PropertyCallbackInfo<Value>& info);
   static void GetHost(Local<String> name,
                       const PropertyCallbackInfo<Value>& info);
   static void GetUserAgent(Local<String> name,
                            const PropertyCallbackInfo<Value>& info);
 
   // Callbacks that access maps
   static void MapGet(Local<Name> name, const PropertyCallbackInfo<Value>& info);
   static void MapSet(Local<Name> name, Local<Value> value,
                      const PropertyCallbackInfo<Value>& info);
 
   // Utility methods for wrapping C++ objects as JavaScript objects,
   // and going back again.
-  Handle<Object> WrapMap(map<string, string>* obj);
-  static map<string, string>* UnwrapMap(Handle<Object> obj);
-  Handle<Object> WrapRequest(HttpRequest* obj);
-  static HttpRequest* UnwrapRequest(Handle<Object> obj);
+  Local<Object> WrapMap(map<string, string>* obj);
+  static map<string, string>* UnwrapMap(Local<Object> obj);
+  Local<Object> WrapRequest(HttpRequest* obj);
+  static HttpRequest* UnwrapRequest(Local<Object> obj);
 
   Isolate* GetIsolate() { return isolate_; }
 
   Isolate* isolate_;
-  Handle<String> script_;
-  Persistent<Context> context_;
-  Persistent<Function> process_;
-  static Persistent<ObjectTemplate> request_template_;
-  static Persistent<ObjectTemplate> map_template_;
+  Local<String> script_;
+  Global<Context> context_;
+  Global<Function> process_;
+  static Global<ObjectTemplate> request_template_;
+  static Global<ObjectTemplate> map_template_;
 };
 
 
 // -------------------------
 // --- P r o c e s s o r ---
 // -------------------------
 
 
 static void LogCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() < 1) return;
   HandleScope scope(args.GetIsolate());
-  Handle<Value> arg = args[0];
+  Local<Value> arg = args[0];
   String::Utf8Value value(arg);
   HttpRequestProcessor::Log(*value);
 }
 
 
 // Execute the script and fetch the Process method.
 bool JsHttpRequestProcessor::Initialize(map<string, string>* opts,
                                         map<string, string>* output) {
   // Create a handle scope to hold the temporary references.
   HandleScope handle_scope(GetIsolate());
 
   // Create a template for the global object where we set the
   // built-in global functions.
-  Handle<ObjectTemplate> global = ObjectTemplate::New(GetIsolate());
-  global->Set(String::NewFromUtf8(GetIsolate(), "log"),
+  Local<ObjectTemplate> global = ObjectTemplate::New(GetIsolate());
+  global->Set(String::NewFromUtf8(GetIsolate(), "log", NewStringType::kNormal)
+                  .ToLocalChecked(),
               FunctionTemplate::New(GetIsolate(), LogCallback));
 
   // Each processor gets its own context so different processors don't
   // affect each other. Context::New returns a persistent handle which
   // is what we need for the reference to remain after we return from
   // this method. That persistent handle has to be disposed in the
   // destructor.
-  v8::Handle<v8::Context> context = Context::New(GetIsolate(), NULL, global);
+  v8::Local<v8::Context> context = Context::New(GetIsolate(), NULL, global);
   context_.Reset(GetIsolate(), context);
 
   // Enter the new context so all the following operations take place
   // within it.
   Context::Scope context_scope(context);
 
   // Make the options mapping available within the context
   if (!InstallMaps(opts, output))
     return false;
 
   // Compile and run the script
   if (!ExecuteScript(script_))
     return false;
 
   // The script compiled and ran correctly.  Now we fetch out the
   // Process function from the global object.
-  Handle<String> process_name = String::NewFromUtf8(GetIsolate(), "Process");
-  Handle<Value> process_val = context->Global()->Get(process_name);
-
+  Local<String> process_name =
+      String::NewFromUtf8(GetIsolate(), "Process", NewStringType::kNormal)
+          .ToLocalChecked();
+  Local<Value> process_val;
   // If there is no Process function, or if it is not a function,
   // bail out
-  if (!process_val->IsFunction()) return false;
+  if (!context->Global()->Get(context, process_name).ToLocal(&process_val) ||
+      !process_val->IsFunction()) {
+    return false;
+  }
 
   // It is a function; cast it to a Function
-  Handle<Function> process_fun = Handle<Function>::Cast(process_val);
+  Local<Function> process_fun = Local<Function>::Cast(process_val);
 
-  // Store the function in a Persistent handle, since we also want
+  // Store the function in a Global handle, since we also want
   // that to remain after this call returns
   process_.Reset(GetIsolate(), process_fun);
 
   // All done; all went well
   return true;
 }
 
 
-bool JsHttpRequestProcessor::ExecuteScript(Handle<String> script) {
+bool JsHttpRequestProcessor::ExecuteScript(Local<String> script) {
   HandleScope handle_scope(GetIsolate());
 
   // We're just about to compile the script; set up an error handler to
   // catch any exceptions the script might throw.
   TryCatch try_catch(GetIsolate());
 
+  Local<Context> context(GetIsolate()->GetCurrentContext());
+
   // Compile the script and check for errors.
-  Handle<Script> compiled_script = Script::Compile(script);
-  if (compiled_script.IsEmpty()) {
+  Local<Script> compiled_script;
+  if (!Script::Compile(context, script).ToLocal(&compiled_script)) {
     String::Utf8Value error(try_catch.Exception());
     Log(*error);
     // The script failed to compile; bail out.
     return false;
   }
 
   // Run the script!
-  Handle<Value> result = compiled_script->Run();
-  if (result.IsEmpty()) {
+  Local<Value> result;
+  if (!compiled_script->Run(context).ToLocal(&result)) {
     // The TryCatch above is still in effect and will have caught the error.
     String::Utf8Value error(try_catch.Exception());
     Log(*error);
     // Running the script failed; bail out.
     return false;
   }
   return true;
 }
 
 
 bool JsHttpRequestProcessor::InstallMaps(map<string, string>* opts,
                                          map<string, string>* output) {
   HandleScope handle_scope(GetIsolate());
 
   // Wrap the map object in a JavaScript wrapper
-  Handle<Object> opts_obj = WrapMap(opts);
+  Local<Object> opts_obj = WrapMap(opts);
 
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(GetIsolate(), context_);
 
   // Set the options object as a property on the global object.
-  context->Global()->Set(String::NewFromUtf8(GetIsolate(), "options"),
-                         opts_obj);
+  context->Global()
+      ->Set(context,
+            String::NewFromUtf8(GetIsolate(), "options", NewStringType::kNormal)
+                .ToLocalChecked(),
+            opts_obj)
+      .FromJust();
 
-  Handle<Object> output_obj = WrapMap(output);
-  context->Global()->Set(String::NewFromUtf8(GetIsolate(), "output"),
-                         output_obj);
+  Local<Object> output_obj = WrapMap(output);
+  context->Global()
+      ->Set(context,
+            String::NewFromUtf8(GetIsolate(), "output", NewStringType::kNormal)
+                .ToLocalChecked(),
+            output_obj)
+      .FromJust();
 
   return true;
 }
 
 
 bool JsHttpRequestProcessor::Process(HttpRequest* request) {
   // Create a handle scope to keep the temporary object references.
   HandleScope handle_scope(GetIsolate());
 
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(GetIsolate(), context_);
 
   // Enter this processor's context so all the remaining operations
   // take place there
   Context::Scope context_scope(context);
 
   // Wrap the C++ request object in a JavaScript wrapper
-  Handle<Object> request_obj = WrapRequest(request);
+  Local<Object> request_obj = WrapRequest(request);
 
   // Set up an exception handler before calling the Process function
   TryCatch try_catch(GetIsolate());
 
   // Invoke the process function, giving the global object as 'this'
   // and one argument, the request.
   const int argc = 1;
-  Handle<Value> argv[argc] = { request_obj };
+  Local<Value> argv[argc] = {request_obj};
   v8::Local<v8::Function> process =
       v8::Local<v8::Function>::New(GetIsolate(), process_);
-  Handle<Value> result = process->Call(context->Global(), argc, argv);
-  if (result.IsEmpty()) {
+  Local<Value> result;
+  if (!process->Call(context, context->Global(), argc, argv).ToLocal(&result)) {
     String::Utf8Value error(try_catch.Exception());
     Log(*error);
     return false;
   } else {
     return true;
   }
 }
 
 
 JsHttpRequestProcessor::~JsHttpRequestProcessor() {
   // Dispose the persistent handles.  When noone else has any
   // references to the objects stored in the handles they will be
   // automatically reclaimed.
   context_.Reset();
   process_.Reset();
 }
 
 
-Persistent<ObjectTemplate> JsHttpRequestProcessor::request_template_;
-Persistent<ObjectTemplate> JsHttpRequestProcessor::map_template_;
+Global<ObjectTemplate> JsHttpRequestProcessor::request_template_;
+Global<ObjectTemplate> JsHttpRequestProcessor::map_template_;
 
 
 // -----------------------------------
 // --- A c c e s s i n g   M a p s ---
 // -----------------------------------
 
 // Utility function that wraps a C++ http request object in a
 // JavaScript object.
-Handle<Object> JsHttpRequestProcessor::WrapMap(map<string, string>* obj) {
-  // Handle scope for temporary handles.
+Local<Object> JsHttpRequestProcessor::WrapMap(map<string, string>* obj) {
+  // Local scope for temporary handles.
   EscapableHandleScope handle_scope(GetIsolate());
 
   // Fetch the template for creating JavaScript map wrappers.
   // It only has to be created once, which we do on demand.
   if (map_template_.IsEmpty()) {
-    Handle<ObjectTemplate> raw_template = MakeMapTemplate(GetIsolate());
+    Local<ObjectTemplate> raw_template = MakeMapTemplate(GetIsolate());
     map_template_.Reset(GetIsolate(), raw_template);
   }
-  Handle<ObjectTemplate> templ =
+  Local<ObjectTemplate> templ =
       Local<ObjectTemplate>::New(GetIsolate(), map_template_);
 
   // Create an empty map wrapper.
-  Local<Object> result = templ->NewInstance();
+  Local<Object> result =
+      templ->NewInstance(GetIsolate()->GetCurrentContext()).ToLocalChecked();
 
   // Wrap the raw C++ pointer in an External so it can be referenced
   // from within JavaScript.
-  Handle<External> map_ptr = External::New(GetIsolate(), obj);
+  Local<External> map_ptr = External::New(GetIsolate(), obj);
 
   // Store the map pointer in the JavaScript wrapper.
   result->SetInternalField(0, map_ptr);
 
   // Return the result through the current handle scope.  Since each
   // of these handles will go away when the handle scope is deleted
   // we need to call Close to let one, the result, escape into the
   // outer handle scope.
   return handle_scope.Escape(result);
 }
 
 
 // Utility function that extracts the C++ map pointer from a wrapper
 // object.
-map<string, string>* JsHttpRequestProcessor::UnwrapMap(Handle<Object> obj) {
-  Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));
+map<string, string>* JsHttpRequestProcessor::UnwrapMap(Local<Object> obj) {
+  Local<External> field = Local<External>::Cast(obj->GetInternalField(0));
   void* ptr = field->Value();
   return static_cast<map<string, string>*>(ptr);
 }
 
 
 // Convert a JavaScript string to a std::string.  To not bother too
 // much with string encodings we just use ascii.
 string ObjectToString(Local<Value> value) {
   String::Utf8Value utf8_value(value);
   return string(*utf8_value);
@@ skipping 11 matching lines @@
   string key = ObjectToString(Local<String>::Cast(name));
 
   // Look up the value if it exists using the standard STL ideom.
   map<string, string>::iterator iter = obj->find(key);
 
   // If the key is not present return an empty handle as signal
   if (iter == obj->end()) return;
 
   // Otherwise fetch the value and wrap it in a JavaScript string
   const string& value = (*iter).second;
-  info.GetReturnValue().Set(String::NewFromUtf8(
-      info.GetIsolate(), value.c_str(), String::kNormalString,
-      static_cast<int>(value.length())));
+  info.GetReturnValue().Set(
+      String::NewFromUtf8(info.GetIsolate(), value.c_str(),
+                          NewStringType::kNormal,
+                          static_cast<int>(value.length())).ToLocalChecked());
 }
 
 
 void JsHttpRequestProcessor::MapSet(Local<Name> name, Local<Value> value_obj,
                                     const PropertyCallbackInfo<Value>& info) {
   if (name->IsSymbol()) return;
 
   // Fetch the map wrapped by this object.
   map<string, string>* obj = UnwrapMap(info.Holder());
 
   // Convert the key and value to std::strings.
   string key = ObjectToString(Local<String>::Cast(name));
   string value = ObjectToString(value_obj);
 
   // Update the map.
   (*obj)[key] = value;
 
   // Return the value; any non-empty handle will work.
   info.GetReturnValue().Set(value_obj);
 }
 
 
-Handle<ObjectTemplate> JsHttpRequestProcessor::MakeMapTemplate(
+Local<ObjectTemplate> JsHttpRequestProcessor::MakeMapTemplate(
     Isolate* isolate) {
   EscapableHandleScope handle_scope(isolate);
 
   Local<ObjectTemplate> result = ObjectTemplate::New(isolate);
   result->SetInternalFieldCount(1);
   result->SetHandler(NamedPropertyHandlerConfiguration(MapGet, MapSet));
 
   // Again, return the result through the current handle scope.
   return handle_scope.Escape(result);
 }
 
 
 // -------------------------------------------
 // --- A c c e s s i n g   R e q u e s t s ---
 // -------------------------------------------
 
 /**
  * Utility function that wraps a C++ http request object in a
  * JavaScript object.
  */
-Handle<Object> JsHttpRequestProcessor::WrapRequest(HttpRequest* request) {
-  // Handle scope for temporary handles.
+Local<Object> JsHttpRequestProcessor::WrapRequest(HttpRequest* request) {
+  // Local scope for temporary handles.
   EscapableHandleScope handle_scope(GetIsolate());
 
   // Fetch the template for creating JavaScript http request wrappers.
   // It only has to be created once, which we do on demand.
   if (request_template_.IsEmpty()) {
-    Handle<ObjectTemplate> raw_template = MakeRequestTemplate(GetIsolate());
+    Local<ObjectTemplate> raw_template = MakeRequestTemplate(GetIsolate());
     request_template_.Reset(GetIsolate(), raw_template);
   }
-  Handle<ObjectTemplate> templ =
+  Local<ObjectTemplate> templ =
       Local<ObjectTemplate>::New(GetIsolate(), request_template_);
 
   // Create an empty http request wrapper.
-  Local<Object> result = templ->NewInstance();
+  Local<Object> result =
+      templ->NewInstance(GetIsolate()->GetCurrentContext()).ToLocalChecked();
 
   // Wrap the raw C++ pointer in an External so it can be referenced
   // from within JavaScript.
-  Handle<External> request_ptr = External::New(GetIsolate(), request);
+  Local<External> request_ptr = External::New(GetIsolate(), request);
 
   // Store the request pointer in the JavaScript wrapper.
   result->SetInternalField(0, request_ptr);
 
   // Return the result through the current handle scope.  Since each
   // of these handles will go away when the handle scope is deleted
   // we need to call Close to let one, the result, escape into the
   // outer handle scope.
   return handle_scope.Escape(result);
 }
 
 
 /**
  * Utility function that extracts the C++ http request object from a
  * wrapper object.
  */
-HttpRequest* JsHttpRequestProcessor::UnwrapRequest(Handle<Object> obj) {
-  Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));
+HttpRequest* JsHttpRequestProcessor::UnwrapRequest(Local<Object> obj) {
+  Local<External> field = Local<External>::Cast(obj->GetInternalField(0));
   void* ptr = field->Value();
   return static_cast<HttpRequest*>(ptr);
 }
 
 
 void JsHttpRequestProcessor::GetPath(Local<String> name,
                                      const PropertyCallbackInfo<Value>& info) {
   // Extract the C++ request object from the JavaScript wrapper.
   HttpRequest* request = UnwrapRequest(info.Holder());
 
   // Fetch the path.
   const string& path = request->Path();
 
   // Wrap the result in a JavaScript string and return it.
-  info.GetReturnValue().Set(String::NewFromUtf8(
-      info.GetIsolate(), path.c_str(), String::kNormalString,
-      static_cast<int>(path.length())));
+  info.GetReturnValue().Set(
+      String::NewFromUtf8(info.GetIsolate(), path.c_str(),
+                          NewStringType::kNormal,
+                          static_cast<int>(path.length())).ToLocalChecked());
 }
 
 
 void JsHttpRequestProcessor::GetReferrer(
     Local<String> name,
     const PropertyCallbackInfo<Value>& info) {
   HttpRequest* request = UnwrapRequest(info.Holder());
   const string& path = request->Referrer();
-  info.GetReturnValue().Set(String::NewFromUtf8(
-      info.GetIsolate(), path.c_str(), String::kNormalString,
-      static_cast<int>(path.length())));
+  info.GetReturnValue().Set(
+      String::NewFromUtf8(info.GetIsolate(), path.c_str(),
+                          NewStringType::kNormal,
+                          static_cast<int>(path.length())).ToLocalChecked());
 }
 
 
 void JsHttpRequestProcessor::GetHost(Local<String> name,
                                      const PropertyCallbackInfo<Value>& info) {
   HttpRequest* request = UnwrapRequest(info.Holder());
   const string& path = request->Host();
-  info.GetReturnValue().Set(String::NewFromUtf8(
-      info.GetIsolate(), path.c_str(), String::kNormalString,
-      static_cast<int>(path.length())));
+  info.GetReturnValue().Set(
+      String::NewFromUtf8(info.GetIsolate(), path.c_str(),
+                          NewStringType::kNormal,
+                          static_cast<int>(path.length())).ToLocalChecked());
 }
 
 
 void JsHttpRequestProcessor::GetUserAgent(
     Local<String> name,
     const PropertyCallbackInfo<Value>& info) {
   HttpRequest* request = UnwrapRequest(info.Holder());
   const string& path = request->UserAgent();
-  info.GetReturnValue().Set(String::NewFromUtf8(
-      info.GetIsolate(), path.c_str(), String::kNormalString,
-      static_cast<int>(path.length())));
+  info.GetReturnValue().Set(
+      String::NewFromUtf8(info.GetIsolate(), path.c_str(),
+                          NewStringType::kNormal,
+                          static_cast<int>(path.length())).ToLocalChecked());
 }
 
 
-Handle<ObjectTemplate> JsHttpRequestProcessor::MakeRequestTemplate(
+Local<ObjectTemplate> JsHttpRequestProcessor::MakeRequestTemplate(
     Isolate* isolate) {
   EscapableHandleScope handle_scope(isolate);
 
   Local<ObjectTemplate> result = ObjectTemplate::New(isolate);
   result->SetInternalFieldCount(1);
 
   // Add accessors for each of the fields of the request.
   result->SetAccessor(
-      String::NewFromUtf8(isolate, "path", String::kInternalizedString),
+      String::NewFromUtf8(isolate, "path", NewStringType::kInternalized)
+          .ToLocalChecked(),
       GetPath);
   result->SetAccessor(
-      String::NewFromUtf8(isolate, "referrer", String::kInternalizedString),
+      String::NewFromUtf8(isolate, "referrer", NewStringType::kInternalized)
+          .ToLocalChecked(),
       GetReferrer);
   result->SetAccessor(
-      String::NewFromUtf8(isolate, "host", String::kInternalizedString),
+      String::NewFromUtf8(isolate, "host", NewStringType::kInternalized)
+          .ToLocalChecked(),
       GetHost);
   result->SetAccessor(
-      String::NewFromUtf8(isolate, "userAgent", String::kInternalizedString),
+      String::NewFromUtf8(isolate, "userAgent", NewStringType::kInternalized)
+          .ToLocalChecked(),
       GetUserAgent);
 
   // Again, return the result through the current handle scope.
   return handle_scope.Escape(result);
 }
 
 
 // --- Test ---
 
 
@@ skipping 45 matching lines @@
     } else {
       string key = arg.substr(0, index);
       string value = arg.substr(index+1);
       (*options)[key] = value;
     }
   }
 }
 
 
 // Reads a file into a v8 string.
-Handle<String> ReadFile(Isolate* isolate, const string& name) {
+MaybeLocal<String> ReadFile(Isolate* isolate, const string& name) {
   FILE* file = fopen(name.c_str(), "rb");
-  if (file == NULL) return Handle<String>();
+  if (file == NULL) return MaybeLocal<String>();
 
   fseek(file, 0, SEEK_END);
   size_t size = ftell(file);
   rewind(file);
 
   char* chars = new char[size + 1];
   chars[size] = '\0';
   for (size_t i = 0; i < size;) {
     i += fread(&chars[i], 1, size - i, file);
     if (ferror(file)) {
       fclose(file);
-      return Handle<String>();
+      return MaybeLocal<String>();
     }
   }
   fclose(file);
-  Handle<String> result = String::NewFromUtf8(
-      isolate, chars, String::kNormalString, static_cast<int>(size));
+  MaybeLocal<String> result = String::NewFromUtf8(
+      isolate, chars, NewStringType::kNormal, static_cast<int>(size));
   delete[] chars;
   return result;
 }
 
 
 const int kSampleSize = 6;
 StringHttpRequest kSampleRequests[kSampleSize] = {
   StringHttpRequest("/process.cc", "localhost", "google.com", "firefox"),
   StringHttpRequest("/", "localhost", "google.net", "firefox"),
   StringHttpRequest("/", "localhost", "google.org", "safari"),
@@ skipping 32 matching lines @@
   if (file.empty()) {
     fprintf(stderr, "No script was specified.\n");
     return 1;
   }
   ArrayBufferAllocator array_buffer_allocator;
   Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = &array_buffer_allocator;
   Isolate* isolate = Isolate::New(create_params);
   Isolate::Scope isolate_scope(isolate);
   HandleScope scope(isolate);
-  Handle<String> source = ReadFile(isolate, file);
-  if (source.IsEmpty()) {
+  Local<String> source;
+  if (!ReadFile(isolate, file).ToLocal(&source)) {
     fprintf(stderr, "Error reading '%s'.\n", file.c_str());
     return 1;
   }
   JsHttpRequestProcessor processor(isolate, source);
   map<string, string> output;
   if (!processor.Initialize(&options, &output)) {
     fprintf(stderr, "Error initializing processor.\n");
     return 1;
   }
   if (!ProcessEntries(&processor, kSampleSize, kSampleRequests))
     return 1;
   PrintMap(&output);
 }