Standalone Mojo Javascript application

mojo/apps/js/js_app.cc

 // Copyright 2014 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 "mojo/apps/js/js_app.h"
 
 #include "base/bind.h"
 #include "gin/array_buffer.h"
 #include "gin/converter.h"
 #include "mojo/apps/js/application_delegate_impl.h"
 #include "mojo/apps/js/mojo_module.h"
-#include "mojo/common/data_pipe_utils.h"
 
 namespace mojo {
 namespace apps {
 
-JSApp::JSApp(ApplicationDelegateImpl* content_handler_app,
-             const std::string& url,
-             URLResponsePtr content)
-    : content_handler_app_(content_handler_app),
-      url_(url),
-      content_(content.Pass()),
-      thread_("Mojo JS " + url),
-      content_handler_task_runner_(
+JSApp::JSApp(ApplicationDelegateImpl* app_delegate_impl)
+    : app_delegate_impl_(app_delegate_impl),
+      thread_("Mojo JS "),

[Aaron Boodman, 2014/10/01 04:25:44]

Remove trailing space.

[hansmuller, 2014/10/01 15:40:12]

Done.

+      app_delegate_impl_task_runner_(
           base::MessageLoop::current()->task_runner()) {
-  CHECK(on_content_handler_thread());
+  CHECK(on_app_delegate_impl_thread());
   runner_delegate_.AddBuiltinModule(Mojo::kModuleName,
                                     base::Bind(Mojo::GetModule, this));
 }
 
 JSApp::~JSApp() {
 }
 
 bool JSApp::Start() {
-  CHECK(!js_app_task_runner_.get() && on_content_handler_thread());
+  CHECK(!js_app_task_runner_.get() && on_app_delegate_impl_thread());
   base::Thread::Options thread_options(base::MessageLoop::TYPE_IO, 0);
   thread_.StartWithOptions(thread_options);
 
   // TODO(hansmuller): check thread_.StartWithOptions() return value.
   // TODO(hansmuller): need to funnel Run() failures back to the caller.
 
   thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&JSApp::Run, base::Unretained(this)));
   return true;
 }
 
 void JSApp::Quit() {
   CHECK(on_js_app_thread());
 
   // The terminate operation is posted to the message_loop so that
   // the shell_runner isn't destroyed before this JS function returns.
   thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&JSApp::Terminate, base::Unretained(this)));
 }
 
 Handle JSApp::ConnectToService(const std::string& application_url,
                                const std::string& interface_name) {
   CHECK(on_js_app_thread());
   MessagePipe pipe;
 
-  content_handler_task_runner_->PostTask(
+  app_delegate_impl_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ApplicationDelegateImpl::ConnectToService,
-                 base::Unretained(content_handler_app_),
+                 base::Unretained(app_delegate_impl_),
                  base::Passed(pipe.handle1.Pass()),
                  application_url,
                  interface_name));
 
   return pipe.handle0.release();
 }
 
 void JSApp::Run() {
-  CHECK(!js_app_task_runner_.get() && !on_content_handler_thread());
+  CHECK(!js_app_task_runner_.get() && !on_app_delegate_impl_thread());
   js_app_task_runner_ = base::MessageLoop::current()->task_runner();
 
-  // TODO(hansmuller): check the return value and fail gracefully.
-  std::string module;
-  common::BlockingCopyToString(content_->body.Pass(), &module);
+  std::string source;
+  std::string file_name;
+  Load(&source, &file_name);  // TODO(hansmuller): handle Load() failure.
 
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kStrictMode,
                                  gin::ArrayBufferAllocator::SharedInstance());
   isolate_holder_.reset(new gin::IsolateHolder());
   isolate_holder_->AddRunMicrotasksObserver();
 
   shell_runner_.reset(
       new gin::ShellRunner(&runner_delegate_, isolate_holder_->isolate()));
 
-  // TODO(hansmuller): exiting this scope here is OK?
   gin::Runner::Scope scope(shell_runner_.get());
-  shell_runner_->Run(module.c_str(), url_.c_str());
+  shell_runner_->Run(source.c_str(), file_name.c_str());
 }
 
 void JSApp::Terminate() {
   isolate_holder_->RemoveRunMicrotasksObserver();
-  shell_runner_.reset(NULL);
+  shell_runner_.reset(nullptr);
 
   // This JSApp's thread must be stopped on the thread that started it. Ask the
-  // content_handler_app_ to erase its AppVector entry for this app, which
+  // app_delegate_impl_ to erase its AppVector entry for this app, which
   // implicitly destroys this JSApp and stops its thread.
-  content_handler_task_runner_->PostTask(
+  app_delegate_impl_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ApplicationDelegateImpl::QuitJSApp,
-                 base::Unretained(content_handler_app_),
+                 base::Unretained(app_delegate_impl_),
                  base::Unretained(this)));
 }
 
-bool JSApp::on_content_handler_thread() const {
-  return content_handler_task_runner_.get() &&
-         content_handler_task_runner_.get() ==
+bool JSApp::on_app_delegate_impl_thread() const {
+  return app_delegate_impl_task_runner_.get() &&
+         app_delegate_impl_task_runner_.get() ==
              base::MessageLoop::current()->task_runner().get();
 }
 
 bool JSApp::on_js_app_thread() const {
   return js_app_task_runner_.get() &&
          js_app_task_runner_.get() ==
              base::MessageLoop::current()->task_runner().get();
 }
 
 }  // namespace apps
 }  // namespace mojo