void initializeWithoutV8(WebKitPlatformSupport* webKitPlatformSupport)
{
ASSERT(!s_webKitInitialized);
s_webKitInitialized = true;
#if OS(DARWIN)
InitWebCoreSystemInterface();
#endif
ASSERT(webKitPlatformSupport);
ASSERT(!s_webKitPlatformSupport);
s_webKitPlatformSupport = webKitPlatformSupport;
Platform::initialize(s_webKitPlatformSupport);
WTF::initializeThreading();
WTF::initializeMainThread();
WTF::AtomicString::init();
// There are some code paths (for example, running WebKit in the browser
// process and calling into LocalStorage before anything else) where the
// UTF8 string encoding tables are used on a background thread before
// they're set up. This is a problem because their set up routines assert
// they're running on the main WebKitThread. It might be possible to make
// the initialization thread-safe, but given that so many code paths use
// this, initializing this lazily probably doesn't buy us much.
WebCore::UTF8Encoding();
}
void initializeWebCoreQt()
{
static bool initialized = false;
if (initialized)
return;
#if !LOG_DISABLED
WebCore::initializeLoggingChannelsIfNecessary();
#endif // !LOG_DISABLED
ScriptController::initializeThreading();
WTF::initializeMainThread();
WebCore::SecurityPolicy::setLocalLoadPolicy(WebCore::SecurityPolicy::AllowLocalLoadsForLocalAndSubstituteData);
PlatformStrategiesQt::initialize();
QtWebElementRuntime::initialize();
RenderThemeQt::setCustomTheme(RenderThemeQStyle::create, new ScrollbarThemeQStyle);
#if USE(QTKIT)
InitWebCoreSystemInterface();
#endif
// QWebSettings::SearchCancelButtonGraphic
Image::setPlatformResource("searchCancelButton", QApplication::style()->standardPixmap(QStyle::SP_DialogCloseButton).toImage());
// QWebSettings::SearchCancelButtonPressedGraphic
Image::setPlatformResource("searchCancelButtonPressed", QApplication::style()->standardPixmap(QStyle::SP_DialogCloseButton).toImage());
initialized = true;
}
void InitializeWebKit2()
{
#if PLATFORM(MAC)
InitWebCoreSystemInterface();
#endif
JSC::initializeThreading();
WTF::initializeMainThread();
WebCore::RunLoop::initializeMainRunLoop();
#if !LOG_DISABLED
WebCore::initializeLoggingChannelsIfNecessary();
WebKit::initializeLogChannelsIfNecessary();
#endif // !LOG_DISABLED
}
bool Root::init(FileString homeDirectory, FileString subprocessDirectory, unsigned int extra_argc, const char* extra_argv[] ) {
new base::AtExitManager();
FilePath subprocess;
// convert extra arguments in a more useful form
std::vector< std::string > extra_args;
if( extra_argc > 0 )
{
for( unsigned int arg_idx = 0; arg_idx < extra_argc; ++arg_idx )
{
const char* raw_arg = extra_argv[ arg_idx ];
assert( raw_arg );
extra_args.push_back( raw_arg );
}
}
{
// From <base/command_line.h>:
// Initialize the current process CommandLine singleton. On Windows,
// ignores its arguments (we instead parse GetCommandLineW()
// directly) because we don't trust the CRT's parsing of the command
// line, but it still must be called to set up the command line.
// This means that on windows, we have to call ::Init with whatever we feel
// like (since this is the only way to create the static CommandLine instance),
// and then we have manually call ParseFromString.
// (InitFromArgv does not exist on OS_WIN!)
#if defined(OS_WIN)
FilePath module_dir;
if (subprocessDirectory.size()) {
module_dir = FilePath(subprocessDirectory.get<FilePath::StringType>());
} else {
PathService::Get(base::DIR_MODULE, &module_dir);
}
#ifdef _DEBUG
subprocess = module_dir.Append(L"berkelium_d.exe");
#else
subprocess = module_dir.Append(L"berkelium.exe");
#endif
std::wstring subprocess_str = L"berkelium --enable-webgl --browser-subprocess-path=";
subprocess_str += L"\"";
subprocess_str += subprocess.value();
subprocess_str += L"\"";
// add extra arguments if any
if( !extra_args.empty() )
{
for( unsigned int arg_idx = 0, arg_count = extra_args.size(); arg_idx < arg_count; ++arg_idx )
{
const std::string& str_arg = extra_args[ arg_idx ];
std::wstring wstr_arg( str_arg.begin(), str_arg.end() );
subprocess_str += L" " + wstr_arg;
}
}
//std::wcout << "Berkelium subprocess_str : " << subprocess_str;
CommandLine::Init(0, NULL);
CommandLine::ForCurrentProcess()->ParseFromString(subprocess_str);
#elif defined(OS_MACOSX)
FilePath app_contents;
PathService::Get(base::FILE_EXE, &app_contents);
FilePath module_dir;
if (subprocessDirectory.size()) {
module_dir = FilePath(subprocessDirectory.get<FilePath::StringType>());
} else {
module_dir = app_contents.DirName();
}
subprocess = module_dir.Append("berkelium");
std::string subprocess_str = "--browser-subprocess-path=";
subprocess_str += subprocess.value();
std::vector<const char*> argv;
argv.push_back( "berkelium" );
argv.push_back( subprocess_str.c_str() );
argv.push_back( "--enable-webgl" );
for( std::vector<std::string>::iterator it = extra_args.begin(); it != extra_args.end(); ++it )
{
argv.push_back( it->c_str() );
}
//for( std::vector<const char*>::iterator it = argv.begin(); it != argv.end(); ++it )
// std::cout << "Berkelium arg : " << *it;
CommandLine::Init( argv.size(), &argv[0] );
#elif defined(OS_POSIX)
FilePath module_file;
PathService::Get(base::FILE_EXE, &module_file);
FilePath module_dir;
if (subprocessDirectory.size()) {
module_dir = FilePath(subprocessDirectory.get<FilePath::StringType>());
} else {
module_dir = module_file.DirName();
}
subprocess = module_dir.Append("berkelium");
std::string subprocess_str = "--browser-subprocess-path=";
subprocess_str += subprocess.value();
std::vector<const char*> argv;
argv.push_back( "berkelium" );
argv.push_back( subprocess_str.c_str() );
argv.push_back( "--enable-webgl" );
for( std::vector<std::string>::iterator it = extra_args.begin(); it != extra_args.end(); ++it )
{
argv.push_back( it->c_str() );
}
//for( std::vector<const char*>::iterator it = argv.begin(); it != argv.end(); ++it )
// std::cout << "Berkelium arg : " << *it;
CommandLine::Init( argv.size(), &argv[0]) ;
#endif
}
PathService::Override(base::FILE_EXE, subprocess);
#if !defined(OS_WIN)
/// Temporary SingletonLock fix:
// Do not do this for child processes--they should only be initialized.
// Children should never delete the lock.
if (signal(SIGINT, handleINT) == SIG_IGN) {
signal(SIGINT, SIG_IGN);
}
if (signal(SIGHUP, handleINT) == SIG_IGN) {
signal(SIGHUP, SIG_IGN);
}
if (signal(SIGTERM, handleINT) == SIG_IGN) {
signal(SIGTERM, SIG_IGN);
}
#endif
chrome::RegisterPathProvider();
ui::RegisterPathProvider();
FilePath homedirpath;
if (homeDirectory.data() && homeDirectory.length()) {
FilePath homeDirectoryPath(homeDirectory.get<FilePath::StringType>());
PathService::Override(chrome::DIR_USER_DATA, homeDirectoryPath);
PathService::Override(chrome::DIR_LOGS, homeDirectoryPath);
#if defined(OS_POSIX)
PathService::Override(base::DIR_CACHE, homeDirectoryPath);
#endif
} else {
mTempProfileDir.reset(new ScopedTempDir());
if (mTempProfileDir->CreateUniqueTempDir()) {
PathService::Override(chrome::DIR_USER_DATA, mTempProfileDir->path());
PathService::Override(chrome::DIR_LOGS, mTempProfileDir->path());
#if defined(OS_POSIX)
PathService::Override(base::DIR_CACHE, mTempProfileDir->path());
#endif
}
}
PathService::Get(chrome::DIR_USER_DATA,&homedirpath);
bool SINGLE_PROCESS=false;
#if defined(OS_MACOSX)
base::mac::SetOverrideAppBundlePath(chrome::GetFrameworkBundlePath());
if (SINGLE_PROCESS) {
InitWebCoreSystemInterface();
//CGColorSpaceCreateDeviceRGB();
}
#endif // OS_MACOSX
if (SINGLE_PROCESS) {
RenderProcessHost::set_run_renderer_in_process(true);
}
mMessageLoop.reset(new MessageLoop(MessageLoop::TYPE_UI));
mSysMon.reset(new ui::SystemMonitor);
mTimerMgr.reset(new HighResolutionTimerManager);
mUIThread.reset(new BrowserThread(BrowserThread::UI, mMessageLoop.get()));
mErrorHandler = 0;
#if defined(OS_LINUX)
if (!g_thread_supported ()) // the client application might have already setup glib
{
g_thread_init(NULL);
// Glib type system initialization. Needed at least for gconf,
// used in net/proxy/proxy_config_service_linux.cc. Most likely
// this is superfluous as gtk_init() ought to do this. It's
// definitely harmless, so retained as a reminder of this
// requirement for gconf.
g_type_init();
// gtk_init() can change |argc| and |argv|.
char argv0data[] = "[Berkelium]";
char *argv0 = argv0data;
char **argv = &argv0;
int argc = 1;
gtk_init(&argc, &argv);
}
SetUpGLibLogHandler();
#endif
mProcessSingleton.reset(new ProcessSingleton(homedirpath));
BrowserProcessImpl *browser_process;
browser_process=new BrowserProcessImpl(*CommandLine::ForCurrentProcess());
browser_process->local_state()->RegisterStringPref(prefs::kApplicationLocale, "");
browser_process->local_state()->RegisterBooleanPref(prefs::kMetricsReportingEnabled, false);
assert(g_browser_process == browser_process);
#ifdef OS_WIN
logging::InitLogging(
L"chrome.log",
logging::LOG_NONE,
logging::DONT_LOCK_LOG_FILE,
logging::DELETE_OLD_LOG_FILE,
logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS
);
#else
logging::InitLogging(
"chrome.log",
logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
logging::DONT_LOCK_LOG_FILE,
logging::DELETE_OLD_LOG_FILE,
logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS
);
#endif
logging::InitChromeLogging(
*CommandLine::ForCurrentProcess(),
logging::DELETE_OLD_LOG_FILE);
//APPEND_TO_OLD_LOG_FILE
chrome::RegisterChromeSchemes(); // Required for "chrome-extension://" in InitExtensions
#if defined(OS_LINUX)
const char* sandbox_binary = NULL;
struct stat st;
// In Chromium branded builds, developers can set an environment variable to
// use the development sandbox. See
// http://code.google.com/p/chromium/wiki/LinuxSUIDSandboxDevelopment
if (stat("/proc/self/exe", &st) == 0 && st.st_uid == getuid())
sandbox_binary = getenv("CHROME_DEVEL_SANDBOX");
std::string sandbox_cmd;
if (sandbox_binary && !CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoSandbox))
sandbox_cmd = sandbox_binary;
// Tickle the sandbox host and zygote host so they fork now.
RenderSandboxHostLinux* shost = RenderSandboxHostLinux::GetInstance();
shost->Init(sandbox_cmd);
ZygoteHost* zhost = ZygoteHost::GetInstance();
zhost->Init(sandbox_cmd);
// We want to be sure to init NSPR on the main thread.
base::EnsureNSPRInit();
#endif // defined(OS_LINUX)
SandboxInitWrapper sandbox_wrapper;
#if defined(OS_WIN)
// Get the interface pointer to the BrokerServices or TargetServices,
// depending who we are.
sandbox::SandboxInterfaceInfo sandbox_info = {0};
sandbox_info.broker_services = sandbox::BrokerServicesBase::GetInstance();
sandbox::InitBrokerServices(sandbox_info.broker_services);
if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoSandbox)) {
bool use_winsta = !CommandLine::ForCurrentProcess()->HasSwitch(
switches::kDisableAltWinstation);
// Precreate the desktop and window station used by the renderers.
sandbox::TargetPolicy* policy = sandbox_info.broker_services->CreatePolicy();
sandbox::ResultCode result = policy->CreateAlternateDesktop(use_winsta);
CHECK(sandbox::SBOX_ERROR_FAILED_TO_SWITCH_BACK_WINSTATION != result);
policy->Release();
}
sandbox_wrapper.SetServices(&sandbox_info);
#endif
sandbox_wrapper.InitializeSandbox(*CommandLine::ForCurrentProcess(), "");
bool icu_result = icu_util::Initialize();
CHECK(icu_result);
mRenderViewHostFactory.reset(new MemoryRenderViewHostFactory);
// mNotificationService=new NotificationService();
// ChildProcess* coreProcess=new ChildProcess;
// coreProcess->set_main_thread(new ChildThread);
g_browser_process->SetApplicationLocale("en-US");
ResourceBundle::InitSharedInstance("en-US");// FIXME: lookup locale
// We only load the theme dll in the browser process.
net::CookieMonster::EnableFileScheme();
browser_process->profile_manager();
browser_process->db_thread();
browser_process->file_thread();
browser_process->process_launcher_thread();
browser_process->cache_thread();
browser_process->io_thread();
// Initialize histogram synchronizer system. This is a singleton and is used
// for posting tasks via NewRunnableMethod. Its deleted when it goes out of
// scope. Even though NewRunnableMethod does AddRef and Release, the object
// will not be deleted after the Task is executed.
mHistogramSynchronizer= (new HistogramSynchronizer());
browser::RegisterLocalState(g_browser_process->local_state());
ProfileManager* profile_manager = browser_process->profile_manager();
homedirpath = homedirpath.Append(profile_manager->GetCurrentProfileDir());
{
//std::cout << "Profile path: " << homedirpath.value() << std::endl;
FilePath prefs_path (ProfileManager::GetProfilePrefsPath(homedirpath));
FILE *fp = file_util::OpenFile(prefs_path, "a");
file_util::CloseFile(fp);
FilePath history_path (homedirpath);
history_path = history_path.Append(chrome::kHistoryFilename);
//std::cout << " Profile exists: " << ProfileManager::IsProfile(homedirpath) << std::endl;
}
mProf = profile_manager->GetProfile(homedirpath, false);
if (!mProf) {
mProcessSingleton.reset();
return false;
}
mProf->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled, false);
mProf->GetPrefs()->RegisterStringPref(prefs::kSafeBrowsingClientKey, "");
mProf->GetPrefs()->RegisterStringPref(prefs::kSafeBrowsingWrappedKey, "");
mProf->InitExtensions();
PrefService* user_prefs = mProf->GetPrefs();
DCHECK(user_prefs);
// browser_process->local_state()->SetString(prefs::kApplicationLocale,std::wstring());
mProcessSingleton->Create();
mDNSPrefetch.reset(new chrome_browser_net::PredictorInit(
user_prefs,
browser_process->local_state(),
CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePreconnect)));
BrowserURLHandler::InitURLHandlers();
// From chrome/browser/browser_main.cc
// Register our global network handler for chrome:// and
// chrome-extension:// URLs.
ChromeURLDataManagerBackend::Register();
/*
RegisterExtensionProtocols();
RegisterMetadataURLRequestHandler();
RegisterBlobURLRequestJobFactory();
RegisterFileSystemURLRequestJobFactory();
*/
{
FilePath plugindata = homedirpath.AppendASCII("plugin_");
if (!file_util::CreateDirectory(plugindata)) {
return false;
}
PluginService::GetInstance()->SetChromePluginDataDir(plugindata);
}
PluginService::GetInstance()->LoadChromePlugins(
g_browser_process->resource_dispatcher_host());
mDefaultRequestContext=mProf->GetRequestContext();
if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kRemoteDebuggingPort)) {
std::string debugging_port_str =
CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switches::kRemoteDebuggingPort);
int64 debugging_port = -1;
bool has_debugging_port = base::StringToInt64(debugging_port_str, &debugging_port);
if (has_debugging_port && debugging_port > 0 && debugging_port < 65535) {
devtools_http_handler_ =
Berkelium::DevToolsHttpProtocolHandler::Start(
"127.0.0.1",
static_cast<int>(debugging_port),
""
);
}
}
return true;
}