speedup base
This commit is contained in:
Heilig Benedek
parent
5118def724
commit
6fb6b93003
10 changed files with 1212 additions and 238 deletions
|
|
@ -1,177 +1,216 @@
|
|||
// 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/app/atom_main_delegate.h"
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
#include "atom/app/atom_content_client.h"
|
||||
#include "atom/browser/atom_browser_client.h"
|
||||
#include "atom/browser/relauncher.h"
|
||||
#include "atom/common/google_api_key.h"
|
||||
#include "atom/renderer/atom_renderer_client.h"
|
||||
#include "atom/utility/atom_content_utility_client.h"
|
||||
#include "base/command_line.h"
|
||||
#include "base/debug/stack_trace.h"
|
||||
#include "base/environment.h"
|
||||
#include "base/logging.h"
|
||||
#include "chrome/common/chrome_paths.h"
|
||||
#include "content/public/common/content_switches.h"
|
||||
#include "ui/base/l10n/l10n_util.h"
|
||||
#include "ui/base/resource/resource_bundle.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
namespace {
|
||||
|
||||
const char* kRelauncherProcess = "relauncher";
|
||||
|
||||
bool IsBrowserProcess(base::CommandLine* cmd) {
|
||||
std::string process_type = cmd->GetSwitchValueASCII(switches::kProcessType);
|
||||
return process_type.empty();
|
||||
}
|
||||
|
||||
#if defined(OS_WIN)
|
||||
void InvalidParameterHandler(const wchar_t*, const wchar_t*, const wchar_t*,
|
||||
unsigned int, uintptr_t) {
|
||||
// noop.
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
AtomMainDelegate::AtomMainDelegate() {
|
||||
}
|
||||
|
||||
AtomMainDelegate::~AtomMainDelegate() {
|
||||
}
|
||||
|
||||
bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
|
||||
auto command_line = base::CommandLine::ForCurrentProcess();
|
||||
|
||||
logging::LoggingSettings settings;
|
||||
#if defined(OS_WIN)
|
||||
// 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))
|
||||
std::wcout << std::endl;
|
||||
#if defined(DEBUG)
|
||||
// Print logging to debug.log on Windows
|
||||
settings.logging_dest = logging::LOG_TO_ALL;
|
||||
settings.log_file = L"debug.log";
|
||||
settings.lock_log = logging::LOCK_LOG_FILE;
|
||||
settings.delete_old = logging::DELETE_OLD_LOG_FILE;
|
||||
#else
|
||||
settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
|
||||
#endif // defined(DEBUG)
|
||||
#else // defined(OS_WIN)
|
||||
settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
|
||||
#endif // !defined(OS_WIN)
|
||||
|
||||
// Only enable logging when --enable-logging is specified.
|
||||
std::unique_ptr<base::Environment> env(base::Environment::Create());
|
||||
if (!command_line->HasSwitch(switches::kEnableLogging) &&
|
||||
!env->HasVar("ELECTRON_ENABLE_LOGGING")) {
|
||||
settings.logging_dest = logging::LOG_NONE;
|
||||
logging::SetMinLogLevel(logging::LOG_NUM_SEVERITIES);
|
||||
}
|
||||
|
||||
logging::InitLogging(settings);
|
||||
|
||||
// Logging with pid and timestamp.
|
||||
logging::SetLogItems(true, false, true, false);
|
||||
|
||||
// Enable convient stack printing.
|
||||
bool enable_stack_dumping = env->HasVar("ELECTRON_ENABLE_STACK_DUMPING");
|
||||
#if defined(DEBUG) && defined(OS_LINUX)
|
||||
enable_stack_dumping = true;
|
||||
#endif
|
||||
if (enable_stack_dumping)
|
||||
base::debug::EnableInProcessStackDumping();
|
||||
|
||||
chrome::RegisterPathProvider();
|
||||
|
||||
#if defined(OS_MACOSX)
|
||||
SetUpBundleOverrides();
|
||||
#endif
|
||||
|
||||
#if defined(OS_WIN)
|
||||
// Ignore invalid parameter errors.
|
||||
_set_invalid_parameter_handler(InvalidParameterHandler);
|
||||
#endif
|
||||
|
||||
return brightray::MainDelegate::BasicStartupComplete(exit_code);
|
||||
}
|
||||
|
||||
void AtomMainDelegate::PreSandboxStartup() {
|
||||
brightray::MainDelegate::PreSandboxStartup();
|
||||
|
||||
// Set google API key.
|
||||
std::unique_ptr<base::Environment> env(base::Environment::Create());
|
||||
if (!env->HasVar("GOOGLE_API_KEY"))
|
||||
env->SetVar("GOOGLE_API_KEY", GOOGLEAPIS_API_KEY);
|
||||
|
||||
auto command_line = base::CommandLine::ForCurrentProcess();
|
||||
std::string process_type = command_line->GetSwitchValueASCII(
|
||||
switches::kProcessType);
|
||||
|
||||
// Only append arguments for browser process.
|
||||
if (!IsBrowserProcess(command_line))
|
||||
return;
|
||||
|
||||
// Disable renderer sandbox for most of node's functions.
|
||||
command_line->AppendSwitch(switches::kNoSandbox);
|
||||
|
||||
// Allow file:// URIs to read other file:// URIs by default.
|
||||
command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
|
||||
|
||||
#if defined(OS_MACOSX)
|
||||
// Enable AVFoundation.
|
||||
command_line->AppendSwitch("enable-avfoundation");
|
||||
#endif
|
||||
}
|
||||
|
||||
content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
|
||||
browser_client_.reset(new AtomBrowserClient);
|
||||
return browser_client_.get();
|
||||
}
|
||||
|
||||
content::ContentRendererClient*
|
||||
AtomMainDelegate::CreateContentRendererClient() {
|
||||
renderer_client_.reset(new AtomRendererClient);
|
||||
return renderer_client_.get();
|
||||
}
|
||||
|
||||
content::ContentUtilityClient* AtomMainDelegate::CreateContentUtilityClient() {
|
||||
utility_client_.reset(new AtomContentUtilityClient);
|
||||
return utility_client_.get();
|
||||
}
|
||||
|
||||
int AtomMainDelegate::RunProcess(
|
||||
const std::string& process_type,
|
||||
const content::MainFunctionParams& main_function_params) {
|
||||
if (process_type == kRelauncherProcess)
|
||||
return relauncher::RelauncherMain(main_function_params);
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
|
||||
#if defined(OS_MACOSX)
|
||||
bool AtomMainDelegate::ShouldSendMachPort(const std::string& process_type) {
|
||||
return process_type != kRelauncherProcess;
|
||||
}
|
||||
|
||||
bool AtomMainDelegate::DelaySandboxInitialization(
|
||||
const std::string& process_type) {
|
||||
return process_type == kRelauncherProcess;
|
||||
}
|
||||
#endif
|
||||
|
||||
std::unique_ptr<brightray::ContentClient>
|
||||
AtomMainDelegate::CreateContentClient() {
|
||||
return std::unique_ptr<brightray::ContentClient>(new AtomContentClient);
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
// 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/app/atom_main_delegate.h"
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
#include "atom/app/atom_content_client.h"
|
||||
#include "atom/browser/atom_browser_client.h"
|
||||
#include "atom/browser/relauncher.h"
|
||||
#include "atom/common/google_api_key.h"
|
||||
#include "atom/renderer/atom_renderer_client.h"
|
||||
#include "atom/utility/atom_content_utility_client.h"
|
||||
#include "base/command_line.h"
|
||||
#include "base/debug/stack_trace.h"
|
||||
#include "base/environment.h"
|
||||
#include "base/logging.h"
|
||||
#include "chrome/common/chrome_paths.h"
|
||||
#include "content/public/common/content_switches.h"
|
||||
#include "ui/base/l10n/l10n_util.h"
|
||||
#include "ui/base/resource/resource_bundle.h"
|
||||
|
||||
#include "base/memory/ptr_util.h"
|
||||
#include "content/browser/renderer_host/render_view_host_impl.h"
|
||||
#include "content/browser/renderer_host/render_widget_host_impl.h"
|
||||
#include "atom/browser/osr_window.h"
|
||||
|
||||
#include "content/browser/renderer_host/render_widget_host_view_aura.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
namespace {
|
||||
|
||||
const char* kRelauncherProcess = "relauncher";
|
||||
|
||||
bool IsBrowserProcess(base::CommandLine* cmd) {
|
||||
std::string process_type = cmd->GetSwitchValueASCII(switches::kProcessType);
|
||||
return process_type.empty();
|
||||
}
|
||||
|
||||
#if defined(OS_WIN)
|
||||
void InvalidParameterHandler(const wchar_t*, const wchar_t*, const wchar_t*,
|
||||
unsigned int, uintptr_t) {
|
||||
// noop.
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
AtomMainDelegate::AtomMainDelegate() {
|
||||
}
|
||||
|
||||
AtomMainDelegate::~AtomMainDelegate() {
|
||||
}
|
||||
|
||||
bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
|
||||
auto command_line = base::CommandLine::ForCurrentProcess();
|
||||
|
||||
logging::LoggingSettings settings;
|
||||
#if defined(OS_WIN)
|
||||
// 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))
|
||||
std::wcout << std::endl;
|
||||
#if defined(DEBUG)
|
||||
// Print logging to debug.log on Windows
|
||||
settings.logging_dest = logging::LOG_TO_ALL;
|
||||
settings.log_file = L"debug.log";
|
||||
settings.lock_log = logging::LOCK_LOG_FILE;
|
||||
settings.delete_old = logging::DELETE_OLD_LOG_FILE;
|
||||
#else
|
||||
settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
|
||||
#endif // defined(DEBUG)
|
||||
#else // defined(OS_WIN)
|
||||
settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
|
||||
#endif // !defined(OS_WIN)
|
||||
|
||||
// Only enable logging when --enable-logging is specified.
|
||||
std::unique_ptr<base::Environment> env(base::Environment::Create());
|
||||
if (!command_line->HasSwitch(switches::kEnableLogging) &&
|
||||
!env->HasVar("ELECTRON_ENABLE_LOGGING")) {
|
||||
settings.logging_dest = logging::LOG_NONE;
|
||||
logging::SetMinLogLevel(logging::LOG_NUM_SEVERITIES);
|
||||
}
|
||||
|
||||
logging::InitLogging(settings);
|
||||
|
||||
// Logging with pid and timestamp.
|
||||
logging::SetLogItems(true, false, true, false);
|
||||
|
||||
// Enable convient stack printing.
|
||||
bool enable_stack_dumping = env->HasVar("ELECTRON_ENABLE_STACK_DUMPING");
|
||||
#if defined(DEBUG) && defined(OS_LINUX)
|
||||
enable_stack_dumping = true;
|
||||
#endif
|
||||
if (enable_stack_dumping)
|
||||
base::debug::EnableInProcessStackDumping();
|
||||
|
||||
chrome::RegisterPathProvider();
|
||||
|
||||
#if defined(OS_MACOSX)
|
||||
SetUpBundleOverrides();
|
||||
#endif
|
||||
|
||||
#if defined(OS_WIN)
|
||||
// Ignore invalid parameter errors.
|
||||
_set_invalid_parameter_handler(InvalidParameterHandler);
|
||||
#endif
|
||||
|
||||
render_view_host_factory_.reset(new AtomRenderViewHostFactory);
|
||||
|
||||
return brightray::MainDelegate::BasicStartupComplete(exit_code);
|
||||
}
|
||||
|
||||
void AtomMainDelegate::PreSandboxStartup() {
|
||||
brightray::MainDelegate::PreSandboxStartup();
|
||||
|
||||
// Set google API key.
|
||||
std::unique_ptr<base::Environment> env(base::Environment::Create());
|
||||
if (!env->HasVar("GOOGLE_API_KEY"))
|
||||
env->SetVar("GOOGLE_API_KEY", GOOGLEAPIS_API_KEY);
|
||||
|
||||
auto command_line = base::CommandLine::ForCurrentProcess();
|
||||
std::string process_type = command_line->GetSwitchValueASCII(
|
||||
switches::kProcessType);
|
||||
|
||||
// Only append arguments for browser process.
|
||||
if (!IsBrowserProcess(command_line))
|
||||
return;
|
||||
|
||||
// Disable renderer sandbox for most of node's functions.
|
||||
command_line->AppendSwitch(switches::kNoSandbox);
|
||||
|
||||
// Allow file:// URIs to read other file:// URIs by default.
|
||||
command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
|
||||
|
||||
#if defined(OS_MACOSX)
|
||||
// Enable AVFoundation.
|
||||
command_line->AppendSwitch("enable-avfoundation");
|
||||
#endif
|
||||
}
|
||||
|
||||
content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
|
||||
browser_client_.reset(new AtomBrowserClient);
|
||||
return browser_client_.get();
|
||||
}
|
||||
|
||||
content::ContentRendererClient*
|
||||
AtomMainDelegate::CreateContentRendererClient() {
|
||||
renderer_client_.reset(new AtomRendererClient);
|
||||
return renderer_client_.get();
|
||||
}
|
||||
|
||||
content::ContentUtilityClient* AtomMainDelegate::CreateContentUtilityClient() {
|
||||
utility_client_.reset(new AtomContentUtilityClient);
|
||||
return utility_client_.get();
|
||||
}
|
||||
|
||||
int AtomMainDelegate::RunProcess(
|
||||
const std::string& process_type,
|
||||
const content::MainFunctionParams& main_function_params) {
|
||||
if (process_type == kRelauncherProcess)
|
||||
return relauncher::RelauncherMain(main_function_params);
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
|
||||
#if defined(OS_MACOSX)
|
||||
bool AtomMainDelegate::ShouldSendMachPort(const std::string& process_type) {
|
||||
return process_type != kRelauncherProcess;
|
||||
}
|
||||
|
||||
bool AtomMainDelegate::DelaySandboxInitialization(
|
||||
const std::string& process_type) {
|
||||
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
|
||||
|
|
|
|||
|
|
@ -1,57 +1,75 @@
|
|||
// 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_APP_ATOM_MAIN_DELEGATE_H_
|
||||
#define ATOM_APP_ATOM_MAIN_DELEGATE_H_
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "brightray/common/main_delegate.h"
|
||||
#include "brightray/common/content_client.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
class AtomMainDelegate : public brightray::MainDelegate {
|
||||
public:
|
||||
AtomMainDelegate();
|
||||
~AtomMainDelegate();
|
||||
|
||||
protected:
|
||||
// content::ContentMainDelegate:
|
||||
bool BasicStartupComplete(int* exit_code) override;
|
||||
void PreSandboxStartup() override;
|
||||
content::ContentBrowserClient* CreateContentBrowserClient() override;
|
||||
content::ContentRendererClient* CreateContentRendererClient() override;
|
||||
content::ContentUtilityClient* CreateContentUtilityClient() override;
|
||||
int RunProcess(
|
||||
const std::string& process_type,
|
||||
const content::MainFunctionParams& main_function_params) override;
|
||||
#if defined(OS_MACOSX)
|
||||
bool ShouldSendMachPort(const std::string& process_type) override;
|
||||
bool DelaySandboxInitialization(const std::string& process_type) override;
|
||||
#endif
|
||||
|
||||
// brightray::MainDelegate:
|
||||
std::unique_ptr<brightray::ContentClient> CreateContentClient() override;
|
||||
#if defined(OS_MACOSX)
|
||||
void OverrideChildProcessPath() override;
|
||||
void OverrideFrameworkBundlePath() override;
|
||||
#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_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(AtomMainDelegate);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_APP_ATOM_MAIN_DELEGATE_H_
|
||||
// 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_APP_ATOM_MAIN_DELEGATE_H_
|
||||
#define ATOM_APP_ATOM_MAIN_DELEGATE_H_
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "brightray/common/main_delegate.h"
|
||||
#include "brightray/common/content_client.h"
|
||||
|
||||
#include "content/browser/renderer_host/render_view_host_factory.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
class AtomRenderViewHostFactory : public content::RenderViewHostFactory {
|
||||
public:
|
||||
|
||||
AtomRenderViewHostFactory();
|
||||
~AtomRenderViewHostFactory();
|
||||
|
||||
content::RenderViewHost* CreateRenderViewHost(
|
||||
content::SiteInstance* instance,
|
||||
content::RenderViewHostDelegate* delegate,
|
||||
content::RenderWidgetHostDelegate* widget_delegate,
|
||||
int32_t routing_id,
|
||||
int32_t main_frame_routing_id,
|
||||
bool swapped_out);
|
||||
};
|
||||
|
||||
class AtomMainDelegate : public brightray::MainDelegate {
|
||||
public:
|
||||
AtomMainDelegate();
|
||||
~AtomMainDelegate();
|
||||
|
||||
protected:
|
||||
// content::ContentMainDelegate:
|
||||
bool BasicStartupComplete(int* exit_code) override;
|
||||
void PreSandboxStartup() override;
|
||||
content::ContentBrowserClient* CreateContentBrowserClient() override;
|
||||
content::ContentRendererClient* CreateContentRendererClient() override;
|
||||
content::ContentUtilityClient* CreateContentUtilityClient() override;
|
||||
int RunProcess(
|
||||
const std::string& process_type,
|
||||
const content::MainFunctionParams& main_function_params) override;
|
||||
#if defined(OS_MACOSX)
|
||||
bool ShouldSendMachPort(const std::string& process_type) override;
|
||||
bool DelaySandboxInitialization(const std::string& process_type) override;
|
||||
#endif
|
||||
|
||||
// brightray::MainDelegate:
|
||||
std::unique_ptr<brightray::ContentClient> CreateContentClient() override;
|
||||
#if defined(OS_MACOSX)
|
||||
void OverrideChildProcessPath() override;
|
||||
void OverrideFrameworkBundlePath() override;
|
||||
#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_
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
return false;
|
||||
/*if (dirty_rect.IsEmpty())
|
||||
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) {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
623
atom/browser/osr_window.cc
Normal file
623
atom/browser/osr_window.cc
Normal file
|
|
@ -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
|
||||
206
atom/browser/osr_window.h
Normal file
206
atom/browser/osr_window.h
Normal file
|
|
@ -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_
|
||||
|
|
@ -18,5 +18,10 @@ exports.load = (appUrl) => {
|
|||
})
|
||||
mainWindow.loadURL(appUrl)
|
||||
mainWindow.focus()
|
||||
mainWindow.webContents.on('dom-ready', () => {
|
||||
mainWindow.webContents.beginFrameSubscription(() => {
|
||||
console.log("asd")
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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',
|
||||
|
|
|
|||
Loading…
Reference in a new issue