speedup base

atom/app/atom_main_delegate.cc

@@ -1,177 +1,216 @@
-// Copyright (c) 2013 GitHub, Inc.
+// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
+// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
+// found in the LICENSE file.
-
+
-#include "atom/app/atom_main_delegate.h"
+#include "atom/app/atom_main_delegate.h"
-
+
-#include <string>
+#include <string>
-#include <iostream>
+#include <iostream>
-
+
-#include "atom/app/atom_content_client.h"
+#include "atom/app/atom_content_client.h"
-#include "atom/browser/atom_browser_client.h"
+#include "atom/browser/atom_browser_client.h"
-#include "atom/browser/relauncher.h"
+#include "atom/browser/relauncher.h"
-#include "atom/common/google_api_key.h"
+#include "atom/common/google_api_key.h"
-#include "atom/renderer/atom_renderer_client.h"
+#include "atom/renderer/atom_renderer_client.h"
-#include "atom/utility/atom_content_utility_client.h"
+#include "atom/utility/atom_content_utility_client.h"
-#include "base/command_line.h"
+#include "base/command_line.h"
-#include "base/debug/stack_trace.h"
+#include "base/debug/stack_trace.h"
-#include "base/environment.h"
+#include "base/environment.h"
-#include "base/logging.h"
+#include "base/logging.h"
-#include "chrome/common/chrome_paths.h"
+#include "chrome/common/chrome_paths.h"
-#include "content/public/common/content_switches.h"
+#include "content/public/common/content_switches.h"
-#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/l10n/l10n_util.h"
-#include "ui/base/resource/resource_bundle.h"
+#include "ui/base/resource/resource_bundle.h"
-
+
-namespace atom {
+#include "base/memory/ptr_util.h"
-
+#include "content/browser/renderer_host/render_view_host_impl.h"
-namespace {
+#include "content/browser/renderer_host/render_widget_host_impl.h"
-
+#include "atom/browser/osr_window.h"
-const char* kRelauncherProcess = "relauncher";
+
-
+#include "content/browser/renderer_host/render_widget_host_view_aura.h"
-bool IsBrowserProcess(base::CommandLine* cmd) {
+
-  std::string process_type = cmd->GetSwitchValueASCII(switches::kProcessType);
+namespace atom {
-  return process_type.empty();
+
-}
+namespace {
-
+
-#if defined(OS_WIN)
+const char* kRelauncherProcess = "relauncher";
-void InvalidParameterHandler(const wchar_t*, const wchar_t*, const wchar_t*,
+
-                             unsigned int, uintptr_t) {
+bool IsBrowserProcess(base::CommandLine* cmd) {
-  // noop.
+  std::string process_type = cmd->GetSwitchValueASCII(switches::kProcessType);
-}
+  return process_type.empty();
-#endif
+}
-
+
-}  // namespace
+#if defined(OS_WIN)
-
+void InvalidParameterHandler(const wchar_t*, const wchar_t*, const wchar_t*,
-AtomMainDelegate::AtomMainDelegate() {
+                             unsigned int, uintptr_t) {
-}
+  // noop.
-
+}
-AtomMainDelegate::~AtomMainDelegate() {
+#endif
-}
+
-
+}  // namespace
-bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
+
-  auto command_line = base::CommandLine::ForCurrentProcess();
+AtomMainDelegate::AtomMainDelegate() {
-
+}
-  logging::LoggingSettings settings;
+
-#if defined(OS_WIN)
+AtomMainDelegate::~AtomMainDelegate() {
-  // On Windows the terminal returns immediately, so we add a new line to
+}
-  // prevent output in the same line as the prompt.
+
-  if (IsBrowserProcess(command_line))
+bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
-    std::wcout << std::endl;
+  auto command_line = base::CommandLine::ForCurrentProcess();
-#if defined(DEBUG)
+
-  // Print logging to debug.log on Windows
+  logging::LoggingSettings settings;
-  settings.logging_dest = logging::LOG_TO_ALL;
+#if defined(OS_WIN)
-  settings.log_file = L"debug.log";
+  // On Windows the terminal returns immediately, so we add a new line to
-  settings.lock_log = logging::LOCK_LOG_FILE;
+  // prevent output in the same line as the prompt.
-  settings.delete_old = logging::DELETE_OLD_LOG_FILE;
+  if (IsBrowserProcess(command_line))
-#else
+    std::wcout << std::endl;
-  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+#if defined(DEBUG)
-#endif  // defined(DEBUG)
+  // Print logging to debug.log on Windows
-#else  // defined(OS_WIN)
+  settings.logging_dest = logging::LOG_TO_ALL;
-  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+  settings.log_file = L"debug.log";
-#endif  // !defined(OS_WIN)
+  settings.lock_log = logging::LOCK_LOG_FILE;
-
+  settings.delete_old = logging::DELETE_OLD_LOG_FILE;
-  // Only enable logging when --enable-logging is specified.
+#else
-  std::unique_ptr<base::Environment> env(base::Environment::Create());
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
-  if (!command_line->HasSwitch(switches::kEnableLogging) &&
+#endif  // defined(DEBUG)
-      !env->HasVar("ELECTRON_ENABLE_LOGGING")) {
+#else  // defined(OS_WIN)
-    settings.logging_dest = logging::LOG_NONE;
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
-    logging::SetMinLogLevel(logging::LOG_NUM_SEVERITIES);
+#endif  // !defined(OS_WIN)
-  }
+
-
+  // Only enable logging when --enable-logging is specified.
-  logging::InitLogging(settings);
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
-
+  if (!command_line->HasSwitch(switches::kEnableLogging) &&
-  // Logging with pid and timestamp.
+      !env->HasVar("ELECTRON_ENABLE_LOGGING")) {
-  logging::SetLogItems(true, false, true, false);
+    settings.logging_dest = logging::LOG_NONE;
-
+    logging::SetMinLogLevel(logging::LOG_NUM_SEVERITIES);
-  // Enable convient stack printing.
+  }
-  bool enable_stack_dumping = env->HasVar("ELECTRON_ENABLE_STACK_DUMPING");
+
-#if defined(DEBUG) && defined(OS_LINUX)
+  logging::InitLogging(settings);
-  enable_stack_dumping = true;
+
-#endif
+  // Logging with pid and timestamp.
-  if (enable_stack_dumping)
+  logging::SetLogItems(true, false, true, false);
-    base::debug::EnableInProcessStackDumping();
+
-
+  // Enable convient stack printing.
-  chrome::RegisterPathProvider();
+  bool enable_stack_dumping = env->HasVar("ELECTRON_ENABLE_STACK_DUMPING");
-
+#if defined(DEBUG) && defined(OS_LINUX)
-#if defined(OS_MACOSX)
+  enable_stack_dumping = true;
-  SetUpBundleOverrides();
+#endif
-#endif
+  if (enable_stack_dumping)
-
+    base::debug::EnableInProcessStackDumping();
-#if defined(OS_WIN)
+
-  // Ignore invalid parameter errors.
+  chrome::RegisterPathProvider();
-  _set_invalid_parameter_handler(InvalidParameterHandler);
+
-#endif
+#if defined(OS_MACOSX)
-
+  SetUpBundleOverrides();
-  return brightray::MainDelegate::BasicStartupComplete(exit_code);
+#endif
-}
+
-
+#if defined(OS_WIN)
-void AtomMainDelegate::PreSandboxStartup() {
+  // Ignore invalid parameter errors.
-  brightray::MainDelegate::PreSandboxStartup();
+  _set_invalid_parameter_handler(InvalidParameterHandler);
-
+#endif
-  // Set google API key.
+
-  std::unique_ptr<base::Environment> env(base::Environment::Create());
+  render_view_host_factory_.reset(new AtomRenderViewHostFactory);
-  if (!env->HasVar("GOOGLE_API_KEY"))
+
-    env->SetVar("GOOGLE_API_KEY", GOOGLEAPIS_API_KEY);
+  return brightray::MainDelegate::BasicStartupComplete(exit_code);
-
+}
-  auto command_line = base::CommandLine::ForCurrentProcess();
+
-  std::string process_type = command_line->GetSwitchValueASCII(
+void AtomMainDelegate::PreSandboxStartup() {
-      switches::kProcessType);
+  brightray::MainDelegate::PreSandboxStartup();
-
+
-  // Only append arguments for browser process.
+  // Set google API key.
-  if (!IsBrowserProcess(command_line))
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
-    return;
+  if (!env->HasVar("GOOGLE_API_KEY"))
-
+    env->SetVar("GOOGLE_API_KEY", GOOGLEAPIS_API_KEY);
-  // Disable renderer sandbox for most of node's functions.
+
-  command_line->AppendSwitch(switches::kNoSandbox);
+  auto command_line = base::CommandLine::ForCurrentProcess();
-
+  std::string process_type = command_line->GetSwitchValueASCII(
-  // Allow file:// URIs to read other file:// URIs by default.
+      switches::kProcessType);
-  command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
+
-
+  // Only append arguments for browser process.
-#if defined(OS_MACOSX)
+  if (!IsBrowserProcess(command_line))
-  // Enable AVFoundation.
+    return;
-  command_line->AppendSwitch("enable-avfoundation");
+
-#endif
+  // Disable renderer sandbox for most of node's functions.
-}
+  command_line->AppendSwitch(switches::kNoSandbox);
-
+
-content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
+  // Allow file:// URIs to read other file:// URIs by default.
-  browser_client_.reset(new AtomBrowserClient);
+  command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
-  return browser_client_.get();
+
-}
+#if defined(OS_MACOSX)
-
+  // Enable AVFoundation.
-content::ContentRendererClient*
+  command_line->AppendSwitch("enable-avfoundation");
-    AtomMainDelegate::CreateContentRendererClient() {
+#endif
-  renderer_client_.reset(new AtomRendererClient);
+}
-  return renderer_client_.get();
+
-}
+content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
-
+  browser_client_.reset(new AtomBrowserClient);
-content::ContentUtilityClient* AtomMainDelegate::CreateContentUtilityClient() {
+  return browser_client_.get();
-  utility_client_.reset(new AtomContentUtilityClient);
+}
-  return utility_client_.get();
+
-}
+content::ContentRendererClient*
-
+    AtomMainDelegate::CreateContentRendererClient() {
-int AtomMainDelegate::RunProcess(
+  renderer_client_.reset(new AtomRendererClient);
-    const std::string& process_type,
+  return renderer_client_.get();
-    const content::MainFunctionParams& main_function_params) {
+}
-  if (process_type == kRelauncherProcess)
+
-    return relauncher::RelauncherMain(main_function_params);
+content::ContentUtilityClient* AtomMainDelegate::CreateContentUtilityClient() {
-  else
+  utility_client_.reset(new AtomContentUtilityClient);
-    return -1;
+  return utility_client_.get();
-}
+}
-
+
-#if defined(OS_MACOSX)
+int AtomMainDelegate::RunProcess(
-bool AtomMainDelegate::ShouldSendMachPort(const std::string& process_type) {
+    const std::string& process_type,
-  return process_type != kRelauncherProcess;
+    const content::MainFunctionParams& main_function_params) {
-}
+  if (process_type == kRelauncherProcess)
-
+    return relauncher::RelauncherMain(main_function_params);
-bool AtomMainDelegate::DelaySandboxInitialization(
+  else
-    const std::string& process_type) {
+    return -1;
-  return process_type == kRelauncherProcess;
+}
-}
+
-#endif
+#if defined(OS_MACOSX)
-
+bool AtomMainDelegate::ShouldSendMachPort(const std::string& process_type) {
-std::unique_ptr<brightray::ContentClient>
+  return process_type != kRelauncherProcess;
-AtomMainDelegate::CreateContentClient() {
+}
-  return std::unique_ptr<brightray::ContentClient>(new AtomContentClient);
+
-}
+bool AtomMainDelegate::DelaySandboxInitialization(
-
+    const std::string& process_type) {
-}  // namespace atom
+  return process_type == kRelauncherProcess;
+}
+#endif
+
+std::unique_ptr<brightray::ContentClient>
+AtomMainDelegate::CreateContentClient() {
+  return std::unique_ptr<brightray::ContentClient>(new AtomContentClient);
+}
+
+AtomRenderViewHostFactory::AtomRenderViewHostFactory() {
+  //std::cout << "AtomRenderViewHostFactory" << std::endl;
+  content::RenderViewHostFactory::UnregisterFactory();
+  content::RenderViewHostFactory::RegisterFactory( this );
+}
+
+AtomRenderViewHostFactory::~AtomRenderViewHostFactory() {
+  //std::cout << "~AtomRenderViewHostFactory" << std::endl;
+}
+
+content::RenderViewHost* AtomRenderViewHostFactory::CreateRenderViewHost(
+  content::SiteInstance* instance,
+  content::RenderViewHostDelegate* delegate,
+  content::RenderWidgetHostDelegate* widget_delegate,
+  int32_t routing_id,
+  int32_t main_frame_routing_id,
+  bool swapped_out) {
+
+  auto widget_host_impl = new content::RenderWidgetHostImpl(
+    widget_delegate, instance->GetProcess(), routing_id, false);
+
+  auto view_host_impl = new content::RenderViewHostImpl(instance,
+    base::WrapUnique(widget_host_impl), delegate, main_frame_routing_id,
+    swapped_out, true);
+
+  new OffScreenWindow(widget_host_impl);
+
+  return view_host_impl;
+}
+
+}  // namespace atom

atom/app/atom_main_delegate.h

@@ -1,57 +1,75 @@
-// Copyright (c) 2013 GitHub, Inc.
+// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
+// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
+// found in the LICENSE file.
-
+
-#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_H_
+#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_H_
-#define ATOM_APP_ATOM_MAIN_DELEGATE_H_
+#define ATOM_APP_ATOM_MAIN_DELEGATE_H_
-
+
-#include <string>
+#include <string>
-
+
-#include "brightray/common/main_delegate.h"
+#include "brightray/common/main_delegate.h"
-#include "brightray/common/content_client.h"
+#include "brightray/common/content_client.h"
-
+
-namespace atom {
+#include "content/browser/renderer_host/render_view_host_factory.h"
-
+
-class AtomMainDelegate : public brightray::MainDelegate {
+namespace atom {
- public:
+
-  AtomMainDelegate();
+class AtomRenderViewHostFactory : public content::RenderViewHostFactory {
-  ~AtomMainDelegate();
+public:
-
+
- protected:
+  AtomRenderViewHostFactory();
-  // content::ContentMainDelegate:
+  ~AtomRenderViewHostFactory();
-  bool BasicStartupComplete(int* exit_code) override;
+
-  void PreSandboxStartup() override;
+  content::RenderViewHost* CreateRenderViewHost(
-  content::ContentBrowserClient* CreateContentBrowserClient() override;
+    content::SiteInstance* instance,
-  content::ContentRendererClient* CreateContentRendererClient() override;
+    content::RenderViewHostDelegate* delegate,
-  content::ContentUtilityClient* CreateContentUtilityClient() override;
+    content::RenderWidgetHostDelegate* widget_delegate,
-  int RunProcess(
+    int32_t routing_id,
-      const std::string& process_type,
+    int32_t main_frame_routing_id,
-      const content::MainFunctionParams& main_function_params) override;
+    bool swapped_out);
-#if defined(OS_MACOSX)
+};
-  bool ShouldSendMachPort(const std::string& process_type) override;
+
-  bool DelaySandboxInitialization(const std::string& process_type) override;
+class AtomMainDelegate : public brightray::MainDelegate {
-#endif
+ public:
-
+  AtomMainDelegate();
-  // brightray::MainDelegate:
+  ~AtomMainDelegate();
-  std::unique_ptr<brightray::ContentClient> CreateContentClient() override;
+
-#if defined(OS_MACOSX)
+ protected:
-  void OverrideChildProcessPath() override;
+  // content::ContentMainDelegate:
-  void OverrideFrameworkBundlePath() override;
+  bool BasicStartupComplete(int* exit_code) override;
-#endif
+  void PreSandboxStartup() override;
-
+  content::ContentBrowserClient* CreateContentBrowserClient() override;
- private:
+  content::ContentRendererClient* CreateContentRendererClient() override;
-#if defined(OS_MACOSX)
+  content::ContentUtilityClient* CreateContentUtilityClient() override;
-  void SetUpBundleOverrides();
+  int RunProcess(
-#endif
+      const std::string& process_type,
-
+      const content::MainFunctionParams& main_function_params) override;
-  brightray::ContentClient content_client_;
+#if defined(OS_MACOSX)
-  std::unique_ptr<content::ContentBrowserClient> browser_client_;
+  bool ShouldSendMachPort(const std::string& process_type) override;
-  std::unique_ptr<content::ContentRendererClient> renderer_client_;
+  bool DelaySandboxInitialization(const std::string& process_type) override;
-  std::unique_ptr<content::ContentUtilityClient> utility_client_;
+#endif
-
+
-  DISALLOW_COPY_AND_ASSIGN(AtomMainDelegate);
+  // brightray::MainDelegate:
-};
+  std::unique_ptr<brightray::ContentClient> CreateContentClient() override;
-
+#if defined(OS_MACOSX)
-}  // namespace atom
+  void OverrideChildProcessPath() override;
-
+  void OverrideFrameworkBundlePath() override;
-#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_H_
+#endif
+
+ private:
+#if defined(OS_MACOSX)
+  void SetUpBundleOverrides();
+#endif
+
+  brightray::ContentClient content_client_;
+  std::unique_ptr<content::ContentBrowserClient> browser_client_;
+  std::unique_ptr<content::ContentRendererClient> renderer_client_;
+  std::unique_ptr<content::ContentUtilityClient> utility_client_;
+  std::unique_ptr<AtomRenderViewHostFactory> render_view_host_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomMainDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_H_

atom/browser/api/frame_subscriber.cc

@@ -9,10 +9,24 @@
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "content/public/browser/render_widget_host.h"
 
+#include <iostream>
+#include "content/browser/compositor/image_transport_factory.h"
+#include "cc/surfaces/surface_manager.h"
+#include "cc/surfaces/surface.h"
+#include "cc/output/copy_output_request.h"
+
 namespace atom {
 
 namespace api {
 
+FrameSubscriberRenderWidgetHostView::FrameSubscriberRenderWidgetHostView() {
+  std::cout << "FrameSubscriberRenderWidgetHostView" << std::endl;
+}
+
+FrameSubscriberRenderWidgetHostView::~FrameSubscriberRenderWidgetHostView() {
+  std::cout << "~FrameSubscriberRenderWidgetHostView" << std::endl;
+}
+
 FrameSubscriber::FrameSubscriber(v8::Isolate* isolate,
                                  content::RenderWidgetHostView* view,
                                  const FrameCaptureCallback& callback,
@@ -27,26 +41,51 @@ bool FrameSubscriber::ShouldCaptureFrame(
     scoped_refptr<media::VideoFrame>* storage,
     DeliverFrameCallback* callback) {
   const auto host = view_ ? view_->GetRenderWidgetHost() : nullptr;
+
   if (!view_ || !host)
     return false;
 
-  if (dirty_rect.IsEmpty())
+  /*if (dirty_rect.IsEmpty())
-    return false;
+    return false;*/
 
   gfx::Rect rect = gfx::Rect(view_->GetVisibleViewportSize());
   if (only_dirty_)
     rect = dirty_rect;
 
-  host->CopyFromBackingStore(
+  /*host->CopyFromBackingStore(
       rect,
       rect.size(),
       base::Bind(&FrameSubscriber::OnFrameDelivered,
                  weak_factory_.GetWeakPtr(), callback_, rect),
-      kBGRA_8888_SkColorType);
+      kBGRA_8888_SkColorType);*/
 
+  const auto base = reinterpret_cast<content::RenderWidgetHostViewBase*>(
+    view_);
+  content::ImageTransportFactory* itf =
+    content::ImageTransportFactory::GetInstance();
+  cc::SurfaceManager* sfm = itf->GetSurfaceManager();
+  cc::Surface* surface = sfm->GetSurfaceForId(base->SurfaceIdForTesting());
+
+  std::unique_ptr<cc::CopyOutputRequest> request =
+    cc::CopyOutputRequest::CreateBitmapRequest(
+      base::Bind(&FrameSubscriber::ReadbackResultAsBitmap,
+      base::Unretained(this)));
+
+  surface->RequestCopyOfOutput(std::move(request));
   return false;
 }
 
+void FrameSubscriber::ReadbackResultAsBitmap(
+  std::unique_ptr<cc::CopyOutputResult> result) {
+  std::unique_ptr<SkBitmap> bitmap = result->TakeBitmap();
+
+  SkAutoPixmapUnlock res;
+  if (!bitmap->requestLock(&res))
+    return;
+
+  std::cout << res.pixmap().addr() << std::endl;
+}
+
 void FrameSubscriber::OnFrameDelivered(const FrameCaptureCallback& callback,
   const gfx::Rect& damage_rect, const SkBitmap& bitmap,
   content::ReadbackResponse response) {

atom/browser/api/frame_subscriber.h

@@ -14,10 +14,24 @@
 #include "ui/gfx/geometry/size.h"
 #include "v8/include/v8.h"
 
+#include "content/browser/renderer_host/render_widget_host_view_base.h"
+#include "cc/surfaces/surface_id.h"
+#include "cc/output/copy_output_result.h"
+
 namespace atom {
 
 namespace api {
 
+class FrameSubscriberRenderWidgetHostView
+ : public content::RenderWidgetHostViewBase {
+ public:
+
+  FrameSubscriberRenderWidgetHostView();
+  ~FrameSubscriberRenderWidgetHostView();
+
+  cc::SurfaceId SurfaceId();
+};
+
 class FrameSubscriber : public content::RenderWidgetHostViewFrameSubscriber {
  public:
   using FrameCaptureCallback =
@@ -34,6 +48,9 @@ class FrameSubscriber : public content::RenderWidgetHostViewFrameSubscriber {
                           DeliverFrameCallback* callback) override;
 
  private:
+  void ReadbackResultAsBitmap(
+    std::unique_ptr<cc::CopyOutputResult> result);
+
   void OnFrameDelivered(const FrameCaptureCallback& callback,
     const gfx::Rect& damage_rect, const SkBitmap& bitmap,
     content::ReadbackResponse response);

atom/browser/native_window_views.cc

@@ -55,6 +55,15 @@
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #endif
 
+#include <iostream>
+#include "atom/browser/osr_window.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/context_factory.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread.h"
+#include "ui/gfx/native_widget_types.h"
+
 namespace atom {
 
 namespace {
@@ -321,6 +330,21 @@ NativeWindowViews::~NativeWindowViews() {
   window_->RemoveObserver(this);
 }
 
+void NativeWindowViews::RenderViewCreated(
+    content::RenderViewHost* render_view_host) {
+  std::cout << "NativeWindowViews::RenderViewCreated" << std::endl;
+  NativeWindow::RenderViewCreated(render_view_host);
+
+  content::RenderWidgetHostImpl* impl = content::RenderWidgetHostImpl::FromID(
+      render_view_host->GetProcess()->GetID(),
+      render_view_host->GetRoutingID());
+  if (impl) {
+    ui::Layer* layer = widget()->GetCompositor()->root_layer();
+    ui::Compositor* compositor_ = widget()->GetCompositor();
+    compositor_->RequestNewOutputSurface();
+  }
+}
+
 void NativeWindowViews::Close() {
   if (!IsClosable()) {
     WindowList::WindowCloseCancelled(this);

atom/browser/native_window_views.h

@@ -49,6 +49,7 @@ class NativeWindowViews : public NativeWindow,
   ~NativeWindowViews() override;
 
   // NativeWindow:
+  void RenderViewCreated(content::RenderViewHost*) override;
   void Close() override;
   void CloseImmediately() override;
   void Focus(bool focus) override;

atom/browser/osr_window.cc

@@ -0,0 +1,623 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/osr_window.h"
+#include "third_party/WebKit/public/platform/WebScreenInfo.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_delegate.h"
+#include "content/public/browser/render_widget_host_view_frame_subscriber.h"
+#include "ui/events/latency_info.h"
+#include "content/common/view_messages.h"
+#include "ui/gfx/geometry/dip_util.h"
+#include "base/memory/ptr_util.h"
+#include "content/public/browser/context_factory.h"
+#include "base/single_thread_task_runner.h"
+#include "ui/compositor/layer.h"
+#include "ui/compositor/layer_type.h"
+#include "base/location.h"
+#include "ui/gfx/native_widget_types.h"
+#include <iostream>
+#include <chrono>
+#include <thread>
+
+#include "third_party/skia/include/core/SkSurface.h"
+#include "third_party/skia/include/core/SkPixmap.h"
+#include "cc/output/output_surface_client.h"
+
+#include "content/browser/compositor/software_browser_compositor_output_surface.h"
+
+namespace atom {
+
+OffScreenOutputSurface::OffScreenOutputSurface(
+  std::unique_ptr<cc::SoftwareOutputDevice> device)
+: OutputSurface(nullptr, nullptr, std::move(device)) {
+  std::cout << "OffScreenOutputSurface" << std::endl;
+}
+
+OffScreenOutputSurface::~OffScreenOutputSurface() {
+  std::cout << "~OffScreenOutputSurface" << std::endl;
+}
+
+void OffScreenOutputSurface::SwapBuffers(cc::CompositorFrame* frame) {
+  std::cout << "SwapBuffers" << std::endl;
+
+  base::TimeTicks swap_time = base::TimeTicks::Now();
+  for (auto& latency : frame->metadata.latency_info) {
+    latency.AddLatencyNumberWithTimestamp(
+      ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0, 0, swap_time, 1);
+    latency.AddLatencyNumberWithTimestamp(
+      ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0,
+      swap_time, 1);
+  }
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+    FROM_HERE, base::Bind(&content::RenderWidgetHostImpl::CompositorFrameDrawn,
+      frame->metadata.latency_info));
+
+  client_->DidSwapBuffers();
+  PostSwapBuffersComplete();
+}
+
+bool OffScreenOutputSurface::BindToClient(cc::OutputSurfaceClient* client) {
+  client_ = client;
+  return true;
+}
+
+OffScreenOutputDevice::OffScreenOutputDevice() {
+  std::cout << "OffScreenOutputDevice" << std::endl;
+}
+
+OffScreenOutputDevice::~OffScreenOutputDevice() {
+  std::cout << "~OffScreenOutputDevice" << std::endl;
+}
+
+// Discards any pre-existing backing buffers and allocates memory for a
+// software device of |size|. This must be called before the
+// |SoftwareOutputDevice| can be used in other ways.
+void OffScreenOutputDevice::Resize(
+  const gfx::Size& pixel_size, float scale_factor) {
+  std::cout << "Resize" << std::endl;
+
+  std::cout << pixel_size.width() << "x" << pixel_size.height() << std::endl;
+
+  scale_factor_ = scale_factor;
+  if (viewport_pixel_size_ == pixel_size)
+    return;
+  viewport_pixel_size_ = pixel_size;
+
+  surface_ = SkSurface::MakeRasterN32Premul(
+    viewport_pixel_size_.width(), viewport_pixel_size_.height());
+}
+
+// Called on BeginDrawingFrame. The compositor will draw into the returned
+// SkCanvas. The |SoftwareOutputDevice| implementation needs to provide a
+// valid SkCanvas of at least size |damage_rect|. This class retains ownership
+// of the SkCanvas.
+SkCanvas* OffScreenOutputDevice::BeginPaint(const gfx::Rect& damage_rect) {
+  std::cout << "BeginPaint" << std::endl;
+  damage_rect_ = damage_rect;
+  if (surface_.get())
+    return surface_->getCanvas();
+
+  return nullptr;
+}
+
+// Called on FinishDrawingFrame. The compositor will no longer mutate the the
+// SkCanvas instance returned by |BeginPaint| and should discard any reference
+// that it holds to it.
+void OffScreenOutputDevice::EndPaint() {
+  std::cout << "EndPaint" << std::endl;
+  SkPixmap pixmap;
+  if (surface_->peekPixels(&pixmap)) {
+    std::cout << "OK" << std::endl;
+    for(int i = 0; i < 10; i++) {
+      const uint8_t* addr = reinterpret_cast<const uint8_t*>(pixmap.addr(50,i));
+      for(int j = 0; j < 4; j++)
+        std::cout << std::hex << static_cast<int>(*(addr + j)) << std::dec << " ";
+      std::cout << std::endl;
+    }
+  }
+}
+
+// Discard the backing buffer in the surface provided by this instance.
+void OffScreenOutputDevice::DiscardBackbuffer() {
+  std::cout << "DiscardBackbuffer" << std::endl;
+}
+
+// Ensures that there is a backing buffer available on this instance.
+void OffScreenOutputDevice::EnsureBackbuffer() {
+  std::cout << "EnsureBackbuffer" << std::endl;
+}
+
+// VSyncProvider used to update the timer used to schedule draws with the
+// hardware vsync. Return NULL if a provider doesn't exist.
+gfx::VSyncProvider* OffScreenOutputDevice::GetVSyncProvider() {
+  std::cout << "GetVSyncProvider" << std::endl;
+  return nullptr;
+}
+
+OffScreenWindow::OffScreenWindow(
+  content::RenderWidgetHost* host)
+  : host_(content::RenderWidgetHostImpl::From(host)),
+    delegated_frame_host_(new content::DelegatedFrameHost(this)),
+    focus_(false),
+    size_(gfx::Size(0,0)),
+    scale_(0.0) {
+  std::cout << "OffScreenWindow" << std::endl;
+  //std::this_thread::sleep_for(std::chrono::milliseconds(5000));
+  host_->SetView(this);
+
+  SetLayer(new ui::Layer(ui::LayerType::LAYER_SOLID_COLOR));
+  layer()->SetVisible(true);
+  layer()->set_delegate(this);
+  layer()->set_name("OffScreenWindowLayer");
+  layer()->SetFillsBoundsOpaquely(false);
+
+  ui::ContextFactory* factory = content::GetContextFactory();
+  thread_ = new base::Thread("Compositor");
+  thread_->Start();
+
+  //compositor_ = new ui::Compositor(factory, thread_->task_runner());
+  compositor_ = new ui::Compositor(
+    factory, base::ThreadTaskRunnerHandle::Get());
+  delegated_frame_host_->ResetCompositor();
+  delegated_frame_host_->SetCompositor(compositor_);
+  compositor_->SetRootLayer(layer());
+
+  set_layer_owner_delegate(delegated_frame_host_);
+
+  std::unique_ptr<cc::SoftwareOutputDevice> device(new OffScreenOutputDevice());
+  std::unique_ptr<cc::OutputSurface> output_surface(
+    new OffScreenOutputSurface(
+      std::move(device)));
+
+  std::unique_ptr<gfx::WindowImpl> window_(new AtomCompositorHostWin());
+
+  compositor_->SetOutputSurface(std::move(output_surface));
+  compositor_->SetAcceleratedWidget(window_->hwnd());
+  std::cout << compositor_ << std::endl;
+}
+
+OffScreenWindow::~OffScreenWindow() {
+  std::cout << "~OffScreenWindow" << std::endl;
+}
+
+bool OffScreenWindow::OnMessageReceived(const IPC::Message& message) {
+  std::cout << "OnMessageReceived" << std::endl;
+  std::cout << message.type() << std::endl;
+
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(OffScreenWindow, message)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_SetNeedsBeginFrames,
+                        OnSetNeedsBeginFrames)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void OffScreenWindow::InitAsChild(gfx::NativeView) {
+  std::cout << "InitAsChild" << std::endl;
+}
+
+content::RenderWidgetHost* OffScreenWindow::GetRenderWidgetHost() const {
+  std::cout << "GetRenderWidgetHost" << std::endl;
+  return host_;
+}
+
+void OffScreenWindow::SetSize(const gfx::Size& new_size) {
+  std::cout << "SetSize" << std::endl;
+  std::cout << new_size.width() << "x" << new_size.height() << std::endl;
+  size_ = new_size;
+  compositor_->SetScaleAndSize(scale_, size_);
+}
+
+void OffScreenWindow::SetBounds(const gfx::Rect& new_bounds) {
+  std::cout << "SetBounds" << std::endl;
+  std::cout << new_bounds.width() << "x" << new_bounds.height() << std::endl;
+}
+
+gfx::Vector2dF OffScreenWindow::GetLastScrollOffset() const {
+  std::cout << "GetLastScrollOffset" << std::endl;
+  return last_scroll_offset_;
+}
+
+gfx::NativeView OffScreenWindow::GetNativeView() const {
+  std::cout << "GetNativeView" << std::endl;
+  return static_cast<gfx::NativeView>(NULL);
+}
+
+gfx::NativeViewId OffScreenWindow::GetNativeViewId() const {
+  std::cout << "GetNativeViewId" << std::endl;
+  return static_cast<gfx::NativeViewId>(NULL);
+}
+
+gfx::NativeViewAccessible OffScreenWindow::GetNativeViewAccessible() {
+  std::cout << "GetNativeViewAccessible" << std::endl;
+  return static_cast<gfx::NativeViewAccessible>(NULL);
+}
+
+ui::TextInputClient* OffScreenWindow::GetTextInputClient() {
+  std::cout << "GetTextInputClient" << std::endl;
+  return nullptr;
+}
+
+void OffScreenWindow::Focus() {
+  std::cout << "Focus" << std::endl;
+  focus_ = true;
+}
+
+bool OffScreenWindow::HasFocus() const {
+  std::cout << "HasFocus" << std::endl;
+  return focus_;
+}
+
+bool OffScreenWindow::IsSurfaceAvailableForCopy() const {
+  std::cout << "IsSurfaceAvailableForCopy" << std::endl;
+  return delegated_frame_host_->CanCopyToBitmap();
+}
+
+void OffScreenWindow::Show() {
+  std::cout << "Show" << std::endl;
+  ui::LatencyInfo latency_info;
+
+  if (delegated_frame_host_->HasSavedFrame())
+    latency_info.AddLatencyNumber(
+      ui::TAB_SHOW_COMPONENT, host_->GetLatencyComponentId(), 0);
+
+  delegated_frame_host_->WasShown(latency_info);
+}
+
+void OffScreenWindow::Hide() {
+  std::cout << "Hide" << std::endl;
+  if (host_ && !host_->is_hidden())
+    delegated_frame_host_->WasHidden();
+}
+
+bool OffScreenWindow::IsShowing() {
+  std::cout << "IsShowing" << std::endl;
+  return true;
+}
+
+gfx::Rect OffScreenWindow::GetViewBounds() const {
+  std::cout << "GetViewBounds" << std::endl;
+  return gfx::Rect(size_);
+}
+
+gfx::Size OffScreenWindow::GetVisibleViewportSize() const {
+  std::cout << "GetVisibleViewportSize" << std::endl;
+  return size_;
+}
+
+void OffScreenWindow::SetInsets(const gfx::Insets& insets) {
+  std::cout << "SetInsets" << std::endl;
+  host_->WasResized();
+}
+
+bool OffScreenWindow::LockMouse() {
+  std::cout << "LockMouse" << std::endl;
+  return false;
+}
+
+void OffScreenWindow::UnlockMouse() {
+  std::cout << "UnlockMouse" << std::endl;
+}
+
+bool OffScreenWindow::GetScreenColorProfile(std::vector<char>*) {
+  std::cout << "GetScreenColorProfile" << std::endl;
+  return false;
+}
+
+void OffScreenWindow::ClearCompositorFrame() {
+  std::cout << "ClearCompositorFrame" << std::endl;
+  delegated_frame_host_->ClearDelegatedFrame();
+}
+
+void OffScreenWindow::InitAsPopup(content::RenderWidgetHostView *, const gfx::Rect &) {
+  std::cout << "InitAsPopup" << std::endl;
+}
+
+void OffScreenWindow::InitAsFullscreen(content::RenderWidgetHostView *) {
+  std::cout << "InitAsFullscreen" << std::endl;
+}
+
+void OffScreenWindow::UpdateCursor(const content::WebCursor &) {
+  std::cout << "UpdateCursor" << std::endl;
+}
+
+void OffScreenWindow::SetIsLoading(bool loading) {
+  std::cout << "SetIsLoading" << std::endl;
+  if (!loading) {
+    std::cout << "IsDrawn" << std::endl;
+    std::cout << layer()->IsDrawn() << std::endl;
+    layer()->SchedulePaint(gfx::Rect(size_));
+  }
+}
+
+void OffScreenWindow::TextInputStateChanged(const ViewHostMsg_TextInputState_Params &) {
+  std::cout << "TextInputStateChanged" << std::endl;
+}
+
+void OffScreenWindow::ImeCancelComposition() {
+  std::cout << "ImeCancelComposition" << std::endl;
+}
+
+void OffScreenWindow::RenderProcessGone(base::TerminationStatus,int) {
+  std::cout << "RenderProcessGone" << std::endl;
+  Destroy();
+}
+
+void OffScreenWindow::Destroy() {
+  std::cout << "Destroy" << std::endl;
+  thread_->Stop();
+}
+
+void OffScreenWindow::SetTooltipText(const base::string16 &) {
+  std::cout << "SetTooltipText" << std::endl;
+}
+
+void OffScreenWindow::SelectionBoundsChanged(const ViewHostMsg_SelectionBounds_Params &) {
+  std::cout << "SelectionBoundsChanged" << std::endl;
+}
+
+void OffScreenWindow::CopyFromCompositingSurface(const gfx::Rect& src_subrect,
+  const gfx::Size& dst_size,
+  const content::ReadbackRequestCallback& callback,
+  const SkColorType preferred_color_type) {
+  delegated_frame_host_->CopyFromCompositingSurface(
+    src_subrect, dst_size, callback, preferred_color_type);
+  std::cout << "CopyFromCompositingSurface" << std::endl;
+  delegated_frame_host_->CopyFromCompositingSurface(
+    src_subrect, dst_size, callback, preferred_color_type);
+}
+
+void OffScreenWindow::CopyFromCompositingSurfaceToVideoFrame(
+  const gfx::Rect& src_subrect,
+  const scoped_refptr<media::VideoFrame>& target,
+  const base::Callback<void (const gfx::Rect&, bool)>& callback) {
+  delegated_frame_host_->CopyFromCompositingSurfaceToVideoFrame(
+    src_subrect, target, callback);
+  std::cout << "CopyFromCompositingSurfaceToVideoFrame" << std::endl;
+  delegated_frame_host_->CopyFromCompositingSurfaceToVideoFrame(
+    src_subrect, target, callback);
+}
+
+bool OffScreenWindow::CanCopyToVideoFrame() const {
+  std::cout << "CanCopyToVideoFrame" << std::endl;
+  return delegated_frame_host_->CanCopyToVideoFrame();
+}
+
+void OffScreenWindow::BeginFrameSubscription(
+  std::unique_ptr<content::RenderWidgetHostViewFrameSubscriber> subscriber) {
+  std::cout << "BeginFrameSubscription" << std::endl;
+  delegated_frame_host_->BeginFrameSubscription(std::move(subscriber));
+}
+
+void OffScreenWindow::EndFrameSubscription() {
+  std::cout << "EndFrameSubscription" << std::endl;
+  delegated_frame_host_->EndFrameSubscription();
+}
+
+bool OffScreenWindow::HasAcceleratedSurface(const gfx::Size &) {
+  std::cout << "HasAcceleratedSurface" << std::endl;
+  return false;
+}
+
+void OffScreenWindow::GetScreenInfo(blink::WebScreenInfo* results) {
+  std::cout << "GetScreenInfo" << std::endl;
+
+  results->rect = gfx::Rect(size_);
+  results->availableRect = gfx::Rect(size_);
+  results->depth = 24;
+  results->depthPerComponent = 8;
+  results->deviceScaleFactor = scale_;
+  results->orientationAngle = 0;
+  results->orientationType = blink::WebScreenOrientationLandscapePrimary;
+}
+
+bool OffScreenWindow::GetScreenColorProfile(blink::WebVector<char>*) {
+  std::cout << "GetScreenColorProfile" << std::endl;
+  return false;
+}
+
+gfx::Rect OffScreenWindow::GetBoundsInRootWindow() {
+  std::cout << "GetBoundsInRootWindow" << std::endl;
+  return gfx::Rect(size_);
+}
+
+void OffScreenWindow::LockCompositingSurface() {
+  std::cout << "LockCompositingSurface" << std::endl;
+}
+
+void OffScreenWindow::UnlockCompositingSurface() {
+  std::cout << "UnlockCompositingSurface" << std::endl;
+}
+
+void OffScreenWindow::ImeCompositionRangeChanged(
+  const gfx::Range &, const std::vector<gfx::Rect>&) {
+  std::cout << "ImeCompositionRangeChanged" << std::endl;
+}
+
+int OffScreenWindow::DelegatedFrameHostGetGpuMemoryBufferClientId() const {
+  std::cout << "DelegatedFrameHostGetGpuMemoryBufferClientId" << std::endl;
+  return host_->GetProcess()->GetID();
+}
+
+ui::Layer* OffScreenWindow::DelegatedFrameHostGetLayer() const {
+  std::cout << "DelegatedFrameHostGetLayer" << std::endl;
+  return const_cast<ui::Layer*>(layer());
+}
+
+bool OffScreenWindow::DelegatedFrameHostIsVisible() const {
+  std::cout << "DelegatedFrameHostIsVisible" << std::endl;
+  std::cout << !host_->is_hidden() << std::endl;
+  return !host_->is_hidden();
+}
+
+SkColor OffScreenWindow::DelegatedFrameHostGetGutterColor(SkColor color) const {
+  std::cout << "DelegatedFrameHostGetGutterColor" << std::endl;
+  return color;
+}
+
+gfx::Size OffScreenWindow::DelegatedFrameHostDesiredSizeInDIP() const {
+  std::cout << "DelegatedFrameHostDesiredSizeInDIP" << std::endl;
+  return size_;
+}
+
+bool OffScreenWindow::DelegatedFrameCanCreateResizeLock() const {
+  std::cout << "DelegatedFrameCanCreateResizeLock" << std::endl;
+  return false;
+}
+
+std::unique_ptr<content::ResizeLock>
+  OffScreenWindow::DelegatedFrameHostCreateResizeLock(bool) {
+  std::cout << "DelegatedFrameHostCreateResizeLock" << std::endl;
+  return nullptr;
+}
+
+void OffScreenWindow::DelegatedFrameHostResizeLockWasReleased() {
+  std::cout << "DelegatedFrameHostResizeLockWasReleased" << std::endl;
+  host_->WasResized();
+}
+
+void OffScreenWindow::DelegatedFrameHostSendCompositorSwapAck(
+  int output_surface_id, const cc::CompositorFrameAck& ack) {
+  std::cout << "DelegatedFrameHostSendCompositorSwapAck" << std::endl;
+  host_->Send(new ViewMsg_SwapCompositorFrameAck(host_->GetRoutingID(),
+    output_surface_id, ack));
+}
+
+void OffScreenWindow::DelegatedFrameHostSendReclaimCompositorResources(
+  int output_surface_id, const cc::CompositorFrameAck& ack) {
+  std::cout << "DelegatedFrameHostSendReclaimCompositorResources" << std::endl;
+  host_->Send(new ViewMsg_ReclaimCompositorResources(host_->GetRoutingID(),
+    output_surface_id, ack));
+}
+
+void OffScreenWindow::DelegatedFrameHostOnLostCompositorResources() {
+  std::cout << "DelegatedFrameHostOnLostCompositorResources" << std::endl;
+  host_->ScheduleComposite();
+}
+
+void OffScreenWindow::DelegatedFrameHostUpdateVSyncParameters(
+  const base::TimeTicks& timebase, const base::TimeDelta& interval) {
+  std::cout << "DelegatedFrameHostUpdateVSyncParameters" << std::endl;
+  host_->UpdateVSyncParameters(timebase, interval);
+}
+
+
+
+void OffScreenWindow::OnBeginFrame(const cc::BeginFrameArgs& args) {
+  std::cout << "OnBeginFrame" << std::endl;
+
+  delegated_frame_host_->SetVSyncParameters(args.frame_time, args.interval);
+  host_->Send(new ViewMsg_BeginFrame(host_->GetRoutingID(), args));
+  last_begin_frame_args_ = args;
+}
+
+const cc::BeginFrameArgs& OffScreenWindow::LastUsedBeginFrameArgs() const {
+  std::cout << "LastUsedBeginFrameArgs" << std::endl;
+  return last_begin_frame_args_;
+}
+
+void OffScreenWindow::OnBeginFrameSourcePausedChanged(bool) {
+  std::cout << "OnBeginFrameSourcePausedChanged" << std::endl;
+}
+
+void OffScreenWindow::AsValueInto(base::trace_event::TracedValue *) const {
+  std::cout << "AsValueInto" << std::endl;
+}
+
+gfx::Size OffScreenWindow::GetPhysicalBackingSize() const {
+  std::cout << "GetPhysicalBackingSize" << std::endl;
+  return size_;
+}
+
+void OffScreenWindow::UpdateScreenInfo(gfx::NativeView view) {
+  std::cout << "UpdateScreenInfo" << std::endl;
+  content::RenderWidgetHostImpl* impl = NULL;
+  if (GetRenderWidgetHost())
+    impl = content::RenderWidgetHostImpl::From(GetRenderWidgetHost());
+
+  if (impl && impl->delegate())
+    impl->delegate()->SendScreenRects();
+
+  if (HasDisplayPropertyChanged(view) && impl)
+    impl->NotifyScreenInfoChanged();
+}
+
+gfx::Size OffScreenWindow::GetRequestedRendererSize() const {
+  std::cout << "GetRequestedRendererSize" << std::endl;
+  gfx::Size size = delegated_frame_host_->GetRequestedRendererSize();
+
+  std::cout << size.width() << "x" << size.height() << std::endl;
+
+  return size;
+}
+
+void OffScreenWindow::OnSwapCompositorFrame(uint32_t output_surface_id,
+  cc::CompositorFrame frame) {
+  std::cout << "OnSwapCompositorFrame" << std::endl;
+
+  last_scroll_offset_ = frame.metadata.root_scroll_offset;
+  if (!frame.delegated_frame_data) return;
+
+  delegated_frame_host_->SwapDelegatedFrame(
+    output_surface_id, base::WrapUnique(&frame));
+}
+
+uint32_t OffScreenWindow::SurfaceIdNamespaceAtPoint(
+  cc::SurfaceHittestDelegate* delegate,
+  const gfx::Point& point,
+  gfx::Point* transformed_point) {
+  std::cout << "SurfaceIdNamespaceAtPoint" << std::endl;
+
+  gfx::Point point_in_pixels = gfx::ConvertPointToPixel(scale_, point);
+  cc::SurfaceId id = delegated_frame_host_->SurfaceIdAtPoint(
+      delegate, point_in_pixels, transformed_point);
+  *transformed_point = gfx::ConvertPointToDIP(scale_, *transformed_point);
+
+  if (id.is_null())
+    return GetSurfaceIdNamespace();
+  return id.id_namespace();
+}
+
+uint32_t OffScreenWindow::GetSurfaceIdNamespace() {
+  std::cout << "GetSurfaceIdNamespace" << std::endl;
+  return delegated_frame_host_->GetSurfaceIdNamespace();
+}
+
+void OffScreenWindow::OnPaintLayer(const ui::PaintContext &) {
+  std::cout << "OnPaintLayer" << std::endl;
+}
+
+void OffScreenWindow::OnDelegatedFrameDamage(const gfx::Rect &) {
+  std::cout << "OnDelegatedFrameDamage" << std::endl;
+}
+
+void OffScreenWindow::OnDeviceScaleFactorChanged(float scale) {
+  std::cout << "OnDeviceScaleFactorChanged" << std::endl;
+  scale_ = scale;
+}
+
+base::Closure OffScreenWindow::PrepareForLayerBoundsChange() {
+  std::cout << "PrepareForLayerBoundsChange" << std::endl;
+  return base::Bind(&OffScreenWindow::OnBoundsChanged, base::Unretained(this));
+}
+
+void OffScreenWindow::OnBoundsChanged() {
+  std::cout << "OnBoundsChanged" << std::endl;
+}
+
+void OffScreenWindow::OnSetNeedsBeginFrames(bool needs_begin_frames) {
+  std::cout << "OnSetNeedsBeginFrames" << std::endl;
+}
+
+void OffScreenWindow::SendSwapCompositorFrame(cc::CompositorFrame* frame) {
+  std::cout << "SendSwapCompositorFrame" << std::endl;
+  std::vector<IPC::Message> messages_to_deliver_with_frame;
+  /*host_->Send(new ViewHostMsg_SwapCompositorFrame(host_->GetRoutingID(),
+    10, *frame, messages_to_deliver_with_frame));*/
+}
+
+}  // namespace atom

atom/browser/osr_window.h

@@ -0,0 +1,206 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_OSR_WINDOW_H_
+#define ATOM_BROWSER_OSR_WINDOW_H_
+
+#include "content/browser/renderer_host/render_widget_host_view_base.h"
+#include "content/browser/renderer_host/delegated_frame_host.h"
+#include "content/browser/renderer_host/resize_lock.h"
+#include "third_party/WebKit/public/platform/WebVector.h"
+#include "cc/scheduler/begin_frame_source.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "cc/output/compositor_frame.h"
+#include "ui/gfx/geometry/point.h"
+#include "base/threading/thread.h"
+#include "ui/compositor/compositor.h"
+#include "ui/compositor/layer_delegate.h"
+#include "ui/compositor/layer_owner.h"
+#include "ui/base/ime/text_input_client.h"
+#include "base/process/kill.h"
+
+#include "cc/output/software_output_device.h"
+#include "cc/output/output_surface.h"
+#include "cc/output/output_surface_client.h"
+#include "cc/scheduler/begin_frame_source.h"
+
+#include <windows.h>
+#include "ui/gfx/win/window_impl.h"
+
+namespace atom {
+
+class AtomCompositorHostWin : public gfx::WindowImpl {
+ public:
+  AtomCompositorHostWin() {
+    // Create a hidden 1x1 borderless window.
+    set_window_style(WS_POPUP | WS_SYSMENU);
+    Init(NULL, gfx::Rect(0, 0, 1, 1));
+  }
+
+  ~AtomCompositorHostWin() override {
+    DestroyWindow(hwnd());
+  }
+
+ private:
+  CR_BEGIN_MSG_MAP_EX(CompositorHostWin)
+    CR_MSG_WM_PAINT(OnPaint)
+  CR_END_MSG_MAP()
+
+  void OnPaint(HDC dc) {
+    ValidateRect(hwnd(), NULL);
+  }
+};
+
+class OffScreenWindow
+    : public content::RenderWidgetHostViewBase,
+      public content::DelegatedFrameHostClient,
+      public cc::BeginFrameObserver,
+      public ui::LayerDelegate,
+      public ui::LayerOwner {
+public:
+  OffScreenWindow(content::RenderWidgetHost*);
+  ~OffScreenWindow();
+
+//content::RenderWidgetHostView
+  bool OnMessageReceived(const IPC::Message&) override;
+  void InitAsChild(gfx::NativeView);
+  content::RenderWidgetHost* GetRenderWidgetHost(void) const;
+  void SetSize(const gfx::Size &);
+  void SetBounds(const gfx::Rect &);
+  gfx::Vector2dF GetLastScrollOffset(void) const;
+  gfx::NativeView GetNativeView(void) const;
+  gfx::NativeViewId GetNativeViewId(void) const;
+  gfx::NativeViewAccessible GetNativeViewAccessible(void);
+  ui::TextInputClient* GetTextInputClient() override;
+  void Focus(void);
+  bool HasFocus(void) const;
+  bool IsSurfaceAvailableForCopy(void) const;
+  void Show(void);
+  void Hide(void);
+  bool IsShowing(void);
+  gfx::Rect GetViewBounds(void) const;
+  gfx::Size GetVisibleViewportSize() const override;
+  void SetInsets(const gfx::Insets&) override;
+  bool LockMouse(void);
+  void UnlockMouse(void);
+  bool GetScreenColorProfile(std::vector<char>*);
+
+//content::RenderWidgetHostViewBase
+  void ClearCompositorFrame(void);
+  void InitAsPopup(content::RenderWidgetHostView *, const gfx::Rect &);
+  void InitAsFullscreen(content::RenderWidgetHostView *);
+  void UpdateCursor(const content::WebCursor &);
+  void SetIsLoading(bool);
+  void TextInputStateChanged(const ViewHostMsg_TextInputState_Params &);
+  void ImeCancelComposition(void);
+  void RenderProcessGone(base::TerminationStatus,int);
+  void Destroy(void);
+  void SetTooltipText(const base::string16 &);
+  void SelectionBoundsChanged(const ViewHostMsg_SelectionBounds_Params &);
+  void CopyFromCompositingSurface(const gfx::Rect &,
+    const gfx::Size &,
+    const content::ReadbackRequestCallback &,
+    const SkColorType);
+  void CopyFromCompositingSurfaceToVideoFrame(
+    const gfx::Rect &,
+    const scoped_refptr<media::VideoFrame> &,
+    const base::Callback<void (const gfx::Rect &, bool),
+    base::internal::CopyMode::Copyable> &);
+  bool CanCopyToVideoFrame(void) const;
+  void BeginFrameSubscription(
+    std::unique_ptr<content::RenderWidgetHostViewFrameSubscriber>);
+  void EndFrameSubscription();
+  bool HasAcceleratedSurface(const gfx::Size &);
+  void GetScreenInfo(blink::WebScreenInfo *);
+  bool GetScreenColorProfile(blink::WebVector<char>*);
+  gfx::Rect GetBoundsInRootWindow(void);
+  void LockCompositingSurface(void);
+  void UnlockCompositingSurface(void);
+  void ImeCompositionRangeChanged(
+    const gfx::Range &, const std::vector<gfx::Rect>&);
+
+//content::DelegatedFrameHostClient
+  int DelegatedFrameHostGetGpuMemoryBufferClientId(void) const;
+  ui::Layer *DelegatedFrameHostGetLayer(void) const;
+  bool DelegatedFrameHostIsVisible(void) const;
+  SkColor DelegatedFrameHostGetGutterColor(SkColor) const;
+  gfx::Size DelegatedFrameHostDesiredSizeInDIP(void) const;
+  bool DelegatedFrameCanCreateResizeLock(void) const;
+  std::unique_ptr<content::ResizeLock> DelegatedFrameHostCreateResizeLock(bool);
+  void DelegatedFrameHostResizeLockWasReleased(void);
+  void DelegatedFrameHostSendCompositorSwapAck(
+    int, const cc::CompositorFrameAck &);
+  void DelegatedFrameHostSendReclaimCompositorResources(
+    int, const cc::CompositorFrameAck &);
+  void DelegatedFrameHostOnLostCompositorResources(void);
+  void DelegatedFrameHostUpdateVSyncParameters(
+    const base::TimeTicks &, const base::TimeDelta &);
+
+//cc::BeginFrameObserver
+  void OnBeginFrame(const cc::BeginFrameArgs &);
+  const cc::BeginFrameArgs & LastUsedBeginFrameArgs(void) const;
+  void OnBeginFrameSourcePausedChanged(bool);
+  void AsValueInto(base::trace_event::TracedValue *) const;
+
+  gfx::Size GetPhysicalBackingSize() const;
+  void UpdateScreenInfo(gfx::NativeView view);
+  gfx::Size GetRequestedRendererSize() const;
+  void OnSwapCompositorFrame(uint32_t, cc::CompositorFrame);
+  uint32_t SurfaceIdNamespaceAtPoint(
+    cc::SurfaceHittestDelegate* delegate,
+    const gfx::Point& point,
+    gfx::Point* transformed_point);
+  uint32_t GetSurfaceIdNamespace();
+
+  void OnPaintLayer(const ui::PaintContext &);
+  void OnDelegatedFrameDamage(const gfx::Rect &);
+  void OnDeviceScaleFactorChanged(float);
+  base::Closure PrepareForLayerBoundsChange();
+  void OnBoundsChanged();
+
+  void OnSetNeedsBeginFrames(bool);
+  void SendSwapCompositorFrame(cc::CompositorFrame *);
+private:
+  content::RenderWidgetHostImpl* host_;
+  content::DelegatedFrameHost* delegated_frame_host_;
+  gfx::Vector2dF last_scroll_offset_;
+  bool focus_;
+  gfx::Size size_;
+  float scale_;
+
+  cc::BeginFrameSource* begin_frame_source_;
+  cc::BeginFrameArgs last_begin_frame_args_;
+  bool needs_begin_frames_;
+
+  base::Thread* thread_;
+  ui::Compositor* compositor_;
+};
+
+class OffScreenOutputSurface : public cc::OutputSurface {
+public:
+  OffScreenOutputSurface(
+    std::unique_ptr<cc::SoftwareOutputDevice>);
+  ~OffScreenOutputSurface();
+
+  void SwapBuffers(cc::CompositorFrame *);
+  bool BindToClient(cc::OutputSurfaceClient *);
+};
+
+class OffScreenOutputDevice : public cc::SoftwareOutputDevice {
+public:
+  OffScreenOutputDevice();
+  ~OffScreenOutputDevice();
+
+  void Resize(const gfx::Size& pixel_size, float scale_factor);
+  SkCanvas* BeginPaint(const gfx::Rect& damage_rect);
+  void EndPaint();
+  void DiscardBackbuffer();
+  void EnsureBackbuffer();
+  gfx::VSyncProvider* GetVSyncProvider();
+};
+
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_OSR_WINDOW_H_

default_app/default_app.js

@@ -18,5 +18,10 @@ exports.load = (appUrl) => {
     })
     mainWindow.loadURL(appUrl)
     mainWindow.focus()
+    mainWindow.webContents.on('dom-ready', () => {
+      mainWindow.webContents.beginFrameSubscription(() => {
+        console.log("asd")
+      })
+    })
   })
 }

filenames.gypi

@@ -203,6 +203,8 @@
       'atom/browser/native_window_mac.h',
       'atom/browser/native_window_mac.mm',
       'atom/browser/native_window_observer.h',
+      'atom/browser/osr_window.cc',
+      'atom/browser/osr_window.h',
       'atom/browser/net/asar/asar_protocol_handler.cc',
       'atom/browser/net/asar/asar_protocol_handler.h',
       'atom/browser/net/asar/url_request_asar_job.cc',