Rename xwalk::Runtime to xwalk::XWalkContent

Rename xwalk::Runtime to xwalk::XWalkContent and stop
compiling on Android.

application/browser/application.cc

@@ -21,7 +21,7 @@
 #include "xwalk/application/common/application_manifest_constants.h"
 #include "xwalk/application/common/constants.h"
 #include "xwalk/application/common/manifest_handlers/warp_handler.h"
-#include "xwalk/runtime/browser/runtime.h"
+#include "xwalk/runtime/browser/xwalk_content.h"
 #include "xwalk/runtime/browser/runtime_ui_delegate.h"
 #include "xwalk/runtime/browser/xwalk_browser_context.h"
 #include "xwalk/runtime/browser/xwalk_runner.h"
@@ -204,7 +204,7 @@ ui::WindowShowState Application::GetWindowShowState<Manifest::TYPE_MANIFEST>(
 }
 
 bool Application::Launch(const LaunchParams& launch_params) {
-  if (!runtimes_.empty()) {
+  if (!contents_.empty()) {
     LOG(ERROR) << "Attempt to launch app with id " << id()
                << ", but it is already running.";
     return false;
@@ -220,14 +220,14 @@ bool Application::Launch(const LaunchParams& launch_params) {
 
   remote_debugging_enabled_ = launch_params.remote_debugging;
   auto site = content::SiteInstance::CreateForURL(browser_context_, url);
-  Runtime* runtime = Runtime::Create(browser_context_, site);
-  runtime->set_observer(this);
-  runtimes_.push_back(runtime);
-  render_process_host_ = runtime->GetRenderProcessHost();
+  XWalkContent* content = XWalkContent::Create(browser_context_, site);
+  content->set_observer(this);
+  contents_.push_back(content);
+  render_process_host_ = content->GetRenderProcessHost();
   render_process_host_->AddObserver(this);
-  web_contents_ = runtime->web_contents();
+  web_contents_ = content->web_contents();
   InitSecurityPolicy();
-  runtime->LoadURL(url);
+  content->LoadURL(url);
 
   NativeAppWindow::CreateParams params;
   params.net_wm_pid = launch_params.launcher_pid;
@@ -236,9 +236,9 @@ bool Application::Launch(const LaunchParams& launch_params) {
       GetWindowShowState<Manifest::TYPE_MANIFEST>(launch_params);
 
   window_show_params_ = params;
-  // Only the first runtime can have a launch screen.
+  // Only the first content can have a launch screen.
   params.splash_screen_path = GetSplashScreenPath();
-  runtime->set_ui_delegate(DefaultRuntimeUIDelegate::Create(runtime, params));
+  content->set_ui_delegate(DefaultRuntimeUIDelegate::Create(content, params));
   // We call "Show" after RP is initialized to reduce
   // the application start up time.
 
@@ -256,32 +256,32 @@ GURL Application::GetAbsoluteURLFromKey(const std::string& key) {
 }
 
 void Application::Terminate() {
-  std::vector<Runtime*> to_be_closed(runtimes_.get());
-  for (Runtime* runtime : to_be_closed)
-    runtime->Close();
+  std::vector<XWalkContent*> to_be_closed(contents_.get());
+  for (XWalkContent* content : to_be_closed)
+    content->Close();
 }
 
 int Application::GetRenderProcessHostID() const {
   DCHECK(render_process_host_);
   return render_process_host_->GetID();
 }
 
-void Application::OnNewRuntimeAdded(Runtime* runtime) {
-  runtime->set_remote_debugging_enabled(remote_debugging_enabled_);
-  runtime->set_observer(this);
-  runtime->set_ui_delegate(
-      DefaultRuntimeUIDelegate::Create(runtime, window_show_params_));
-  runtime->Show();
-  runtimes_.push_back(runtime);
+void Application::OnNewContentAdded(XWalkContent* content) {
+  content->set_remote_debugging_enabled(remote_debugging_enabled_);
+  content->set_observer(this);
+  content->set_ui_delegate(
+      DefaultRuntimeUIDelegate::Create(content, window_show_params_));
+  content->Show();
+  contents_.push_back(content);
 }
 
-void Application::OnRuntimeClosed(Runtime* runtime) {
-  auto found = std::find(runtimes_.begin(), runtimes_.end(), runtime);
-  CHECK(found != runtimes_.end());
-  LOG(INFO) << "Application::OnRuntimeClosed " << runtime;
-  runtimes_.erase(found);
+void Application::OnContentClosed(XWalkContent* content) {
+  auto found = std::find(contents_.begin(), contents_.end(), content);
+  CHECK(found != contents_.end());
+  LOG(INFO) << "Application::OnContentClosed " << content;
+  contents_.erase(found);
 
-  if (runtimes_.empty())
+  if (contents_.empty())
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&Application::NotifyTermination,
                    weak_factory_.GetWeakPtr()));
@@ -309,8 +309,8 @@ void Application::NotifyTermination() {
 }
 
 void Application::RenderChannelCreated() {
-  CHECK(!runtimes_.empty());
-  runtimes_.front()->Show();
+  CHECK(!contents_.empty());
+  contents_.front()->Show();
 }
 
 bool Application::UseExtension(const std::string& extension_name) const {

application/browser/application.h

@@ -21,7 +21,8 @@
 #include "ui/base/ui_base_types.h"
 #include "xwalk/application/browser/application_security_policy.h"
 #include "xwalk/application/common/application_data.h"
-#include "xwalk/runtime/browser/runtime.h"
+#include "xwalk/runtime/browser/ui/native_app_window.h"
+#include "xwalk/runtime/browser/xwalk_content.h"
 
 namespace content {
 class RenderProcessHost;
@@ -43,15 +44,15 @@ class ApplicationSecurityPolicy;
 // ApplicationService will delete an Application instance when it is
 // terminated.
 // There's one-to-one correspondence between Application and Render Process
-// Host, obtained from its "runtimes" (pages).
-class Application : public Runtime::Observer,
+// Host, obtained from its "contents" (pages).
+class Application : public XWalkContent::Observer,
                     public content::RenderProcessHostObserver {
  public:
   virtual ~Application();
 
   class Observer {
    public:
-    // Invoked when application is terminated - all its pages (runtimes)
+    // Invoked when application is terminated - all its pages (contents)
     // are closed.
     virtual void OnApplicationTerminated(Application* app) {}
 
@@ -68,7 +69,7 @@ class Application : public Runtime::Observer,
     bool remote_debugging;
   };
 
-  // Closes all the application's runtimes (application pages).
+  // Closes all the application's contents (application pages).
   // NOTE: Application is terminated asynchronously.
   // Please use ApplicationService::Observer::WillDestroyApplication()
   // interface to be notified about actual app termination.
@@ -77,7 +78,7 @@ class Application : public Runtime::Observer,
   // immediately after its termination.
   void Terminate();
 
-  const std::vector<Runtime*>& runtimes() const { return runtimes_.get(); }
+  const std::vector<XWalkContent*>& contents() const { return contents_.get(); }
 
   // Returns the unique application id which is used to distinguish the
   // application amoung both running applications and installed ones
@@ -93,7 +94,7 @@ class Application : public Runtime::Observer,
   // Tells whether the application use the specified extension.
   bool UseExtension(const std::string& extension_name) const;
 
-  // The runtime permission mapping is registered by extension which
+  // The content permission mapping is registered by extension which
   // implements some specific API, for example:
   // "bluetooth" -> "bluetooth.read, bluetooth.write, bluetooth.management"
   // Whenever there comes a API permission request, we can tell whether
@@ -122,16 +123,16 @@ class Application : public Runtime::Observer,
   virtual bool Launch(const LaunchParams& launch_params);
   virtual void InitSecurityPolicy();
 
-  // Runtime::Observer implementation.
-  virtual void OnNewRuntimeAdded(Runtime* runtime) override;
-  virtual void OnRuntimeClosed(Runtime* runtime) override;
+  // XWalkContent::Observer implementation.
+  virtual void OnNewContentAdded(XWalkContent* content) override;
+  virtual void OnContentClosed(XWalkContent* content) override;
 
   // Get the path of splash screen image. Return empty path by default.
   // Sub class can override it to return a specific path.
   virtual base::FilePath GetSplashScreenPath();
 
   XWalkBrowserContext* browser_context_;
-  ScopedVector<Runtime> runtimes_;
+  ScopedVector<XWalkContent> contents_;
   scoped_refptr<ApplicationData> const data_;
   // The application's render process host.
   content::RenderProcessHost* render_process_host_;

application/browser/application_service.cc

@@ -22,7 +22,7 @@
 #include "xwalk/application/common/application_manifest_constants.h"
 #include "xwalk/application/common/application_file_util.h"
 #include "xwalk/application/common/id_util.h"
-#include "xwalk/runtime/browser/runtime.h"
+#include "xwalk/runtime/browser/xwalk_content.h"
 #include "xwalk/runtime/browser/xwalk_browser_context.h"
 #include "xwalk/runtime/common/xwalk_paths.h"
 

application/browser/application_tizen.cc

@@ -44,25 +44,25 @@ namespace application {
 const char kDefaultMediaAppClass[] = "player";
 namespace {
 #if defined(OS_TIZEN_MOBILE)
-void ApplyRootWindowParams(Runtime* runtime,
+void ApplyRootWindowParams(XWalkContent* content,
                            NativeAppWindow::CreateParams* params) {
   if (!params->delegate)
-    params->delegate = runtime;
+    params->delegate = content;
   if (params->bounds.IsEmpty())
     params->bounds = gfx::Rect(0, 0, 840, 600);
 
-  unsigned int fullscreen_options = runtime->fullscreen_options();
+  unsigned int fullscreen_options = content->fullscreen_options();
   if (params->state == ui::SHOW_STATE_FULLSCREEN)
-    fullscreen_options |= Runtime::FULLSCREEN_FOR_LAUNCH;
+    fullscreen_options |= XWalkContent::FULLSCREEN_FOR_LAUNCH;
   else
     fullscreen_options &= ~Runtime::FULLSCREEN_FOR_LAUNCH;
-  runtime->set_fullscreen_options(fullscreen_options);
+  content->set_fullscreen_options(fullscreen_options);
 }
 
-NativeAppWindow* CreateRootWindow(Runtime* runtime,
+NativeAppWindow* CreateRootWindow(XWalkContent* content,
                                   const NativeAppWindow::CreateParams& params) {
   NativeAppWindow::CreateParams effective_params(params);
-  ApplyRootWindowParams(runtime, &effective_params);
+  ApplyRootWindowParams(content, &effective_params);
   return NativeAppWindow::Create(effective_params);
 }
 #endif
@@ -109,11 +109,11 @@ class ScreenOrientationProviderTizen :
       return;
     }
     request_id_ = request_id;
-    const std::vector<Runtime*>& runtimes = app_->runtimes();
-    DCHECK(!runtimes.empty());
+    const std::vector<XWalkContent*>& contents = app_->contents();
+    DCHECK(!contents.empty());
     // FIXME: Probably need better alignment with
     // https://w3c.github.io/screen-orientation/#screen-orientation-lock-lifetime
-    for (auto it = runtimes.begin(); it != runtimes.end(); ++it) {
+    for (auto it = contents.begin(); it != contents.end(); ++it) {
       NativeAppWindow* window = (*it)->window();
       if (window && window->IsActive()) {
         ToNativeAppWindowTizen(window)->LockOrientation(lock);
@@ -157,26 +157,26 @@ ApplicationTizen::~ApplicationTizen() {
 }
 
 void ApplicationTizen::Hide() {
-  DCHECK(!runtimes_.empty());
-  for (auto it = runtimes_.begin(); it != runtimes_.end(); ++it) {
+  DCHECK(!contents_.empty());
+  for (auto it = contents_.begin(); it != contents_.end(); ++it) {
     if ((*it)->window())
       (*it)->window()->Minimize();
   }
 }
 
 void ApplicationTizen::Show() {
-  DCHECK(!runtimes_.empty());
-  for (Runtime* runtime : runtimes_) {
-    if (auto window = runtime->window())
+  DCHECK(!contents_.empty());
+  for (XWalkContent* content : contents_) {
+    if (auto window = content->window())
       window->Restore();
   }
 }
 
 bool ApplicationTizen::Launch(const LaunchParams& launch_params) {
   if (Application::Launch(launch_params)) {
 #if defined(OS_TIZEN_MOBILE)
-    if (!runtimes_.empty()) {
-      root_window_ = CreateRootWindow(*(runtimes_.begin()),
+    if (!contents_.empty()) {
+      root_window_ = CreateRootWindow(*(contents_.begin()),
                                       window_show_params_);
       window_show_params_.parent = root_window_->GetNativeWindow();
       root_window_->Show();
@@ -234,8 +234,8 @@ void ApplicationTizen::Suspend() {
   DCHECK(render_process_host_);
   render_process_host_->Send(new ViewMsg_SuspendJSEngine(true));
 
-  DCHECK(!runtimes_.empty());
-  for (auto it = runtimes_.begin(); it != runtimes_.end(); ++it) {
+  DCHECK(!contents_.empty());
+  for (auto it = contents_.begin(); it != contents_.end(); ++it) {
     if ((*it)->web_contents())
       (*it)->web_contents()->WasHidden();
   }
@@ -249,8 +249,8 @@ void ApplicationTizen::Resume() {
   DCHECK(render_process_host_);
   render_process_host_->Send(new ViewMsg_SuspendJSEngine(false));
 
-  DCHECK(!runtimes_.empty());
-  for (auto it = runtimes_.begin(); it != runtimes_.end(); ++it) {
+  DCHECK(!contents_.empty());
+  for (auto it = contents_.begin(); it != contents_.end(); ++it) {
     if ((*it)->web_contents())
       (*it)->web_contents()->WasShown();
   }
@@ -282,8 +282,8 @@ void ApplicationTizen::DidProcessEvent(
   if (info && !info->hwkey_enabled())
     return;
 
-  for (auto it = runtimes_.begin();
-      it != runtimes_.end(); ++it) {
+  for (auto it = contents_.begin();
+      it != contents_.end(); ++it) {
     (*it)->web_contents()->GetRenderViewHost()->Send(new ViewMsg_HWKeyPressed(
         (*it)->web_contents()->GetRoutingID(), key_event->key_code()));
   }
@@ -299,20 +299,20 @@ void ApplicationTizen::SetUserAgentString(
   cookie_manager_->SetUserAgentString(render_process_host_, user_agent_string);
 }
 
-void ApplicationTizen::OnNewRuntimeAdded(Runtime* runtime) {
-  DCHECK(runtime);
-  Application::OnNewRuntimeAdded(runtime);
+void ApplicationTizen::OnNewContentAdded(XWalkContent* content) {
+  DCHECK(content);
+  Application::OnNewContentAdded(content);
 #if defined(OS_TIZEN_MOBILE)
-  if (root_window_ && runtimes_.size() > 1)
+  if (root_window_ && contents_.size() > 1)
       root_window_->Show();
 #endif
 }
 
-void ApplicationTizen::OnRuntimeClosed(Runtime* runtime) {
-  DCHECK(runtime);
-  Application::OnRuntimeClosed(runtime);
+void ApplicationTizen::OnContentClosed(XWalkContent* content) {
+  DCHECK(content);
+  Application::OnContentClosed(content);
 #if defined(OS_TIZEN_MOBILE)
-  if (runtimes_.empty() && root_window_) {
+  if (contents_.empty() && root_window_) {
     root_window_->Close();
     root_window_ = NULL;
   }

application/browser/application_tizen.h

@@ -42,9 +42,9 @@ class ApplicationTizen :  // NOLINT
 
   virtual base::FilePath GetSplashScreenPath() OVERRIDE;
 
-  // Runtime::Observer implementation.
-  virtual void OnNewRuntimeAdded(Runtime* runtime) OVERRIDE;
-  virtual void OnRuntimeClosed(Runtime* runtime) OVERRIDE;
+  // XWalkContent::Observer implementation.
+  virtual void OnNewContentAdded(XWalkContent* content) OVERRIDE;
+  virtual void OnContentClosed(XWalkContent* content) OVERRIDE;
 
 #if defined(USE_OZONE)
   virtual void WillProcessEvent(const ui::PlatformEvent& event) OVERRIDE;

application/extension/application_runtime_extension.cc

@@ -12,7 +12,7 @@
 #include "ui/base/resource/resource_bundle.h"
 #include "xwalk/application/browser/application.h"
 #include "xwalk/application/common/application_data.h"
-#include "xwalk/runtime/browser/runtime.h"
+#include "xwalk/runtime/browser/xwalk_content.h"
 
 using content::BrowserThread;
 

application/extension/application_widget_extension.cc

@@ -19,7 +19,7 @@
 #include "xwalk/application/common/application_manifest_constants.h"
 #include "xwalk/application/common/manifest_handlers/widget_handler.h"
 #include "xwalk/application/extension/application_widget_storage.h"
-#include "xwalk/runtime/browser/runtime.h"
+#include "xwalk/runtime/browser/xwalk_content.h"
 #include "xwalk/runtime/browser/xwalk_browser_context.h"
 #include "xwalk/runtime/browser/xwalk_runner.h"
 #include "xwalk/runtime/common/xwalk_paths.h"

application/test/application_test.cc

@@ -35,7 +35,7 @@ IN_PROC_BROWSER_TEST_F(ApplicationTest, TestMultiApp) {
   test_runner_->WaitForTestNotification();
   EXPECT_EQ(test_runner_->GetTestsResult(), ApiTestRunner::PASS);
   // The App1 has 2 pages: main doc page and "main.html" page.
-  EXPECT_EQ(app1->runtimes().size(), 1);
+  EXPECT_EQ(app1->contents().size(), 1);
 
   EXPECT_EQ(service->active_applications().size(), currently_running_count + 1);
   EXPECT_EQ(service->GetApplicationByID(app1->id()), app1);
@@ -59,7 +59,7 @@ IN_PROC_BROWSER_TEST_F(ApplicationTest, TestMultiApp) {
   EXPECT_EQ(test_runner_->GetTestsResult(), ApiTestRunner::PASS);
 
   // The App2 also has 2 pages: main doc page and "main.html" page.
-  EXPECT_EQ(app2->runtimes().size(), 1);
+  EXPECT_EQ(app2->contents().size(), 1);
 
   // Check that the apps have different IDs and RPH IDs.
   EXPECT_NE(app1->id(), app2->id());