bcarrella
/
cef
mirror of https://bitbucket.org/chromiumembedded/cef
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update to Chromium rev 55388. Note that the Windows 7 SDK is now required to build Chromium. 

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@93 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt 2010-08-09 19:13:43 +00:00
parent 9ab2eca392
commit e5e560c64a
16 changed files with 578 additions and 535 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHROMIUM_BUILD_COMPATIBILITY.txt
View File

@ -51,3 +51,4 @@ Date | CEF Revision | Chromium Revision
2010-02-11 | /trunk@71 | /trunk@38776
2010-03-29 | /trunk@72 | /trunk@42941
2010-06-21 | /trunk@82 | /trunk@50325
2010-08-09 | /trunk@93 | /trunk@55388

5
cef.gyp
View File

@ -219,6 +219,11 @@
'libcef_dll/transfer_util.cpp',
'libcef_dll/transfer_util.h',
],
'link_settings': {
'libraries': [
'-lcomctl32.lib',
],
},
},
{
'target_name': 'libcef_dll_wrapper',

895
libcef/browser_appcache_system.cc
View File

@ -1,445 +1,450 @@
// Copyright (c) 2009 The Chromium Authors. All rights reserved. Use of this
// source code is governed by a BSD-style license that can be found in the
// LICENSE file.
#include "browser_appcache_system.h"
#include "browser_resource_loader_bridge.h"
#include "base/callback.h"
#include "base/lock.h"
#include "base/task.h"
#include "base/waitable_event.h"
#include "webkit/appcache/appcache_interceptor.h"
#include "webkit/appcache/web_application_cache_host_impl.h"
using WebKit::WebApplicationCacheHost;
using WebKit::WebApplicationCacheHostClient;
using appcache::WebApplicationCacheHostImpl;
using appcache::AppCacheBackendImpl;
using appcache::AppCacheInterceptor;
using appcache::AppCacheThread;
namespace appcache {
// An impl of AppCacheThread we need to provide to the appcache lib.
bool AppCacheThread::PostTask(
int id,
const tracked_objects::Location& from_here,
Task* task) {
if (BrowserAppCacheSystem::thread_provider()) {
return BrowserAppCacheSystem::thread_provider()->PostTask(
id, from_here, task);
}
scoped_ptr<Task> task_ptr(task);
MessageLoop* loop = BrowserAppCacheSystem::GetMessageLoop(id);
if (loop)
loop->PostTask(from_here, task_ptr.release());
return loop ? true : false;
}
bool AppCacheThread::CurrentlyOn(int id) {
if (BrowserAppCacheSystem::thread_provider())
return BrowserAppCacheSystem::thread_provider()->CurrentlyOn(id);
return MessageLoop::current() == BrowserAppCacheSystem::GetMessageLoop(id);
}
} // namespace appcache
// BrowserFrontendProxy --------------------------------------------------------
// Proxies method calls from the backend IO thread to the frontend UI thread.
class BrowserFrontendProxy
: public base::RefCountedThreadSafe<BrowserFrontendProxy>,
public appcache::AppCacheFrontend {
public:
explicit BrowserFrontendProxy(BrowserAppCacheSystem* appcache_system)
: system_(appcache_system) {
}
void clear_appcache_system() { system_ = NULL; }
virtual void OnCacheSelected(int host_id, int64 cache_id ,
appcache::Status status) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnCacheSelected,
host_id, cache_id, status));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnCacheSelected(host_id, cache_id, status);
else
NOTREACHED();
}
virtual void OnStatusChanged(const std::vector<int>& host_ids,
appcache::Status status) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnStatusChanged, host_ids, status));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnStatusChanged(host_ids, status);
else
NOTREACHED();
}
virtual void OnEventRaised(const std::vector<int>& host_ids,
appcache::EventID event_id) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnEventRaised, host_ids, event_id));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnEventRaised(host_ids, event_id);
else
NOTREACHED();
}
virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
const GURL& url,
int num_total, int num_complete) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnProgressEventRaised, host_ids, url, num_total, num_complete));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnProgressEventRaised(host_ids, url, num_total, num_complete);
else
NOTREACHED();
}
virtual void OnContentBlocked(int host_id){
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnContentBlocked, host_id));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnContentBlocked(host_id);
else
NOTREACHED();
}
virtual void OnLogMessage(int host_id, appcache::LogLevel log_level,
const std::string& message) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnLogMessage, host_id, log_level, message));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnLogMessage(host_id, log_level, message);
else
NOTREACHED();
}
private:
friend class base::RefCountedThreadSafe<BrowserFrontendProxy>;
~BrowserFrontendProxy() {}
BrowserAppCacheSystem* system_;
};
// BrowserBackendProxy --------------------------------------------------------
// Proxies method calls from the frontend UI thread to the backend IO thread.
class BrowserBackendProxy
: public base::RefCountedThreadSafe<BrowserBackendProxy>,
public appcache::AppCacheBackend {
public:
explicit BrowserBackendProxy(BrowserAppCacheSystem* appcache_system)
: system_(appcache_system), event_(true, false) {
get_status_callback_.reset(
NewCallback(this, &BrowserBackendProxy::GetStatusCallback));
start_update_callback_.reset(
NewCallback(this, &BrowserBackendProxy::StartUpdateCallback));
swap_cache_callback_.reset(
NewCallback(this, &BrowserBackendProxy::SwapCacheCallback));
}
virtual void RegisterHost(int host_id) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::RegisterHost, host_id));
} else if (system_->is_io_thread()) {
system_->backend_impl_->RegisterHost(host_id);
} else {
NOTREACHED();
}
}
virtual void UnregisterHost(int host_id) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::UnregisterHost, host_id));
} else if (system_->is_io_thread()) {
system_->backend_impl_->UnregisterHost(host_id);
} else {
NOTREACHED();
}
}
virtual void SelectCache(int host_id,
const GURL& document_url,
const int64 cache_document_was_loaded_from,
const GURL& manifest_url) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::SelectCache, host_id, document_url,
cache_document_was_loaded_from, manifest_url));
} else if (system_->is_io_thread()) {
system_->backend_impl_->SelectCache(host_id, document_url,
cache_document_was_loaded_from,
manifest_url);
} else {
NOTREACHED();
}
}
virtual void SelectCacheForWorker(
int host_id,
int parent_process_id,
int parent_host_id) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::SelectCacheForWorker, host_id, parent_process_id,
parent_host_id));
} else if (system_->is_io_thread()) {
system_->backend_impl_->SelectCacheForWorker(host_id, parent_process_id,
parent_host_id);
} else {
NOTREACHED();
}
}
virtual void SelectCacheForSharedWorker(
int host_id,
int64 appcache_id){
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::SelectCacheForSharedWorker, host_id, appcache_id));
} else if (system_->is_io_thread()) {
system_->backend_impl_->SelectCacheForSharedWorker(host_id, appcache_id);
} else {
NOTREACHED();
}
}
virtual void MarkAsForeignEntry(int host_id, const GURL& document_url,
int64 cache_document_was_loaded_from) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::MarkAsForeignEntry, host_id, document_url,
cache_document_was_loaded_from));
} else if (system_->is_io_thread()) {
system_->backend_impl_->MarkAsForeignEntry(
host_id, document_url,
cache_document_was_loaded_from);
} else {
NOTREACHED();
}
}
virtual appcache::Status GetStatus(int host_id) {
if (system_->is_ui_thread()) {
status_result_ = appcache::UNCACHED;
event_.Reset();
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::GetStatus, host_id));
event_.Wait();
} else if (system_->is_io_thread()) {
system_->backend_impl_->GetStatusWithCallback(
host_id, get_status_callback_.get(), NULL);
} else {
NOTREACHED();
}
return status_result_;
}
virtual bool StartUpdate(int host_id) {
if (system_->is_ui_thread()) {
bool_result_ = false;
event_.Reset();
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::StartUpdate, host_id));
event_.Wait();
} else if (system_->is_io_thread()) {
system_->backend_impl_->StartUpdateWithCallback(
host_id, start_update_callback_.get(), NULL);
} else {
NOTREACHED();
}
return bool_result_;
}
virtual bool SwapCache(int host_id) {
if (system_->is_ui_thread()) {
bool_result_ = false;
event_.Reset();
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::SwapCache, host_id));
event_.Wait();
} else if (system_->is_io_thread()) {
system_->backend_impl_->SwapCacheWithCallback(
host_id, swap_cache_callback_.get(), NULL);
} else {
NOTREACHED();
}
return bool_result_;
}
void GetStatusCallback(appcache::Status status, void* param) {
status_result_ = status;
event_.Signal();
}
void StartUpdateCallback(bool result, void* param) {
bool_result_ = result;
event_.Signal();
}
void SwapCacheCallback(bool result, void* param) {
bool_result_ = result;
event_.Signal();
}
void SignalEvent() {
event_.Signal();
}
private:
friend class base::RefCountedThreadSafe<BrowserBackendProxy>;
~BrowserBackendProxy() {}
BrowserAppCacheSystem* system_;
base::WaitableEvent event_;
bool bool_result_;
appcache::Status status_result_;
scoped_ptr<appcache::GetStatusCallback> get_status_callback_;
scoped_ptr<appcache::StartUpdateCallback> start_update_callback_;
scoped_ptr<appcache::SwapCacheCallback> swap_cache_callback_;
};
// BrowserAppCacheSystem --------------------------------------------------------
// This class only works for a single process browser.
static const int kSingleProcessId = 1;
// A not so thread safe singleton, but should work for test_shell.
BrowserAppCacheSystem* BrowserAppCacheSystem::instance_ = NULL;
BrowserAppCacheSystem::BrowserAppCacheSystem()
: io_message_loop_(NULL), ui_message_loop_(NULL),
ALLOW_THIS_IN_INITIALIZER_LIST(
backend_proxy_(new BrowserBackendProxy(this))),
ALLOW_THIS_IN_INITIALIZER_LIST(
frontend_proxy_(new BrowserFrontendProxy(this))),
backend_impl_(NULL), service_(NULL), db_thread_("AppCacheDBThread"),
thread_provider_(NULL) {
DCHECK(!instance_);
instance_ = this;
}
static void SignalEvent(base::WaitableEvent* event) {
event->Signal();
}
BrowserAppCacheSystem::~BrowserAppCacheSystem() {
DCHECK(!io_message_loop_ && !backend_impl_ && !service_);
frontend_proxy_->clear_appcache_system(); // in case a task is in transit
instance_ = NULL;
if (db_thread_.IsRunning()) {
// We pump a task thru the db thread to ensure any tasks previously
// scheduled on that thread have been performed prior to return.
base::WaitableEvent event(false, false);
db_thread_.message_loop()->PostTask(FROM_HERE,
NewRunnableFunction(&SignalEvent, &event));
event.Wait();
}
}
void BrowserAppCacheSystem::InitOnUIThread(
const FilePath& cache_directory) {
DCHECK(!ui_message_loop_);
AppCacheThread::Init(DB_THREAD_ID, IO_THREAD_ID);
ui_message_loop_ = MessageLoop::current();
cache_directory_ = cache_directory;
}
void BrowserAppCacheSystem::InitOnIOThread(URLRequestContext* request_context) {
if (!is_initailized_on_ui_thread())
return;
DCHECK(!io_message_loop_);
io_message_loop_ = MessageLoop::current();
io_message_loop_->AddDestructionObserver(this);
if (!db_thread_.IsRunning())
db_thread_.Start();
// Recreate and initialize per each IO thread.
service_ = new appcache::AppCacheService();
backend_impl_ = new appcache::AppCacheBackendImpl();
service_->Initialize(cache_directory_,
BrowserResourceLoaderBridge::GetCacheThread());
service_->set_request_context(request_context);
backend_impl_->Initialize(service_, frontend_proxy_.get(), kSingleProcessId);
AppCacheInterceptor::EnsureRegistered();
}
WebApplicationCacheHost* BrowserAppCacheSystem::CreateCacheHostForWebKit(
WebApplicationCacheHostClient* client) {
if (!is_initailized_on_ui_thread())
return NULL;
DCHECK(is_ui_thread());
if (!is_initialized())
return NULL;
return new WebApplicationCacheHostImpl(client, backend_proxy_.get());
}
void BrowserAppCacheSystem::SetExtraRequestBits(
URLRequest* request, int host_id, ResourceType::Type resource_type) {
if (is_initialized()) {
DCHECK(is_io_thread());
AppCacheInterceptor::SetExtraRequestInfo(
request, service_, kSingleProcessId, host_id, resource_type);
}
}
void BrowserAppCacheSystem::GetExtraResponseBits(
URLRequest* request, int64* cache_id, GURL* manifest_url) {
if (is_initialized()) {
DCHECK(is_io_thread());
AppCacheInterceptor::GetExtraResponseInfo(
request, cache_id, manifest_url);
}
}
void BrowserAppCacheSystem::WillDestroyCurrentMessageLoop() {
DCHECK(is_io_thread());
delete backend_impl_;
delete service_;
backend_impl_ = NULL;
service_ = NULL;
io_message_loop_ = NULL;
// Just in case the main thread is waiting on it.
backend_proxy_->SignalEvent();
}
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "browser_appcache_system.h"
#include "browser_resource_loader_bridge.h"
#include "base/callback.h"
#include "base/lock.h"
#include "base/task.h"
#include "base/waitable_event.h"
#include "webkit/appcache/appcache_interceptor.h"
#include "webkit/appcache/web_application_cache_host_impl.h"
using WebKit::WebApplicationCacheHost;
using WebKit::WebApplicationCacheHostClient;
using appcache::WebApplicationCacheHostImpl;
using appcache::AppCacheBackendImpl;
using appcache::AppCacheInterceptor;
using appcache::AppCacheThread;
namespace appcache {
// An impl of AppCacheThread we need to provide to the appcache lib.
bool AppCacheThread::PostTask(
int id,
const tracked_objects::Location& from_here,
Task* task) {
if (BrowserAppCacheSystem::thread_provider()) {
return BrowserAppCacheSystem::thread_provider()->PostTask(
id, from_here, task);
}
scoped_ptr<Task> task_ptr(task);
MessageLoop* loop = BrowserAppCacheSystem::GetMessageLoop(id);
if (loop)
loop->PostTask(from_here, task_ptr.release());
return loop ? true : false;
}
bool AppCacheThread::CurrentlyOn(int id) {
if (BrowserAppCacheSystem::thread_provider())
return BrowserAppCacheSystem::thread_provider()->CurrentlyOn(id);
return MessageLoop::current() == BrowserAppCacheSystem::GetMessageLoop(id);
}
} // namespace appcache
// BrowserFrontendProxy --------------------------------------------------------
// Proxies method calls from the backend IO thread to the frontend UI thread.
class BrowserFrontendProxy
: public base::RefCountedThreadSafe<BrowserFrontendProxy>,
public appcache::AppCacheFrontend {
public:
explicit BrowserFrontendProxy(BrowserAppCacheSystem* appcache_system)
: system_(appcache_system) {
}
void clear_appcache_system() { system_ = NULL; }
virtual void OnCacheSelected(int host_id,
const appcache::AppCacheInfo& info) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnCacheSelected,
host_id, info));
else if (system_->is_ui_thread()) {
system_->frontend_impl_.OnCacheSelected(host_id, info);
}
else
NOTREACHED();
}
virtual void OnStatusChanged(const std::vector<int>& host_ids,
appcache::Status status) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnStatusChanged, host_ids, status));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnStatusChanged(host_ids, status);
else
NOTREACHED();
}
virtual void OnEventRaised(const std::vector<int>& host_ids,
appcache::EventID event_id) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnEventRaised, host_ids, event_id));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnEventRaised(host_ids, event_id);
else
NOTREACHED();
}
virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
const GURL& url,
int num_total, int num_complete) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnProgressEventRaised,
host_ids, url, num_total, num_complete));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnProgressEventRaised(
host_ids, url, num_total, num_complete);
else
NOTREACHED();
}
virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
const std::string& message) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnErrorEventRaised,
host_ids, message));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnErrorEventRaised(
host_ids, message);
else
NOTREACHED();
}
virtual void OnLogMessage(int host_id,
appcache::LogLevel log_level,
const std::string& message) {
if (!system_)
return;
if (system_->is_io_thread())
system_->ui_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserFrontendProxy::OnLogMessage,
host_id, log_level, message));
else if (system_->is_ui_thread())
system_->frontend_impl_.OnLogMessage(
host_id, log_level, message);
else
NOTREACHED();
}
virtual void OnContentBlocked(int host_id, const GURL& manifest_url) {}
private:
friend class base::RefCountedThreadSafe<BrowserFrontendProxy>;
~BrowserFrontendProxy() {}
BrowserAppCacheSystem* system_;
};
// BrowserBackendProxy --------------------------------------------------------
// Proxies method calls from the frontend UI thread to the backend IO thread.
class BrowserBackendProxy
: public base::RefCountedThreadSafe<BrowserBackendProxy>,
public appcache::AppCacheBackend {
public:
explicit BrowserBackendProxy(BrowserAppCacheSystem* appcache_system)
: system_(appcache_system), event_(true, false) {
get_status_callback_.reset(
NewCallback(this, &BrowserBackendProxy::GetStatusCallback));
start_update_callback_.reset(
NewCallback(this, &BrowserBackendProxy::StartUpdateCallback));
swap_cache_callback_.reset(
NewCallback(this, &BrowserBackendProxy::SwapCacheCallback));
}
virtual void RegisterHost(int host_id) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::RegisterHost, host_id));
} else if (system_->is_io_thread()) {
system_->backend_impl_->RegisterHost(host_id);
} else {
NOTREACHED();
}
}
virtual void UnregisterHost(int host_id) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::UnregisterHost, host_id));
} else if (system_->is_io_thread()) {
system_->backend_impl_->UnregisterHost(host_id);
} else {
NOTREACHED();
}
}
virtual void SelectCache(int host_id,
const GURL& document_url,
const int64 cache_document_was_loaded_from,
const GURL& manifest_url) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::SelectCache, host_id, document_url,
cache_document_was_loaded_from, manifest_url));
} else if (system_->is_io_thread()) {
system_->backend_impl_->SelectCache(host_id, document_url,
cache_document_was_loaded_from,
manifest_url);
} else {
NOTREACHED();
}
}
virtual void GetResourceList(
int host_id,
std::vector<appcache::AppCacheResourceInfo>* resource_infos) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::GetResourceList,
host_id, resource_infos));
} else if (system_->is_io_thread()) {
system_->backend_impl_->GetResourceList(host_id, resource_infos);
} else {
NOTREACHED();
}
}
virtual void SelectCacheForWorker(
int host_id,
int parent_process_id,
int parent_host_id) {
NOTIMPLEMENTED(); // Workers are not supported in test_shell.
}
virtual void SelectCacheForSharedWorker(
int host_id,
int64 appcache_id) {
NOTIMPLEMENTED(); // Workers are not supported in test_shell.
}
virtual void MarkAsForeignEntry(int host_id, const GURL& document_url,
int64 cache_document_was_loaded_from) {
if (system_->is_ui_thread()) {
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::MarkAsForeignEntry, host_id, document_url,
cache_document_was_loaded_from));
} else if (system_->is_io_thread()) {
system_->backend_impl_->MarkAsForeignEntry(
host_id, document_url,
cache_document_was_loaded_from);
} else {
NOTREACHED();
}
}
virtual appcache::Status GetStatus(int host_id) {
if (system_->is_ui_thread()) {
status_result_ = appcache::UNCACHED;
event_.Reset();
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::GetStatus, host_id));
event_.Wait();
} else if (system_->is_io_thread()) {
system_->backend_impl_->GetStatusWithCallback(
host_id, get_status_callback_.get(), NULL);
} else {
NOTREACHED();
}
return status_result_;
}
virtual bool StartUpdate(int host_id) {
if (system_->is_ui_thread()) {
bool_result_ = false;
event_.Reset();
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::StartUpdate, host_id));
event_.Wait();
} else if (system_->is_io_thread()) {
system_->backend_impl_->StartUpdateWithCallback(
host_id, start_update_callback_.get(), NULL);
} else {
NOTREACHED();
}
return bool_result_;
}
virtual bool SwapCache(int host_id) {
if (system_->is_ui_thread()) {
bool_result_ = false;
event_.Reset();
system_->io_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
this, &BrowserBackendProxy::SwapCache, host_id));
event_.Wait();
} else if (system_->is_io_thread()) {
system_->backend_impl_->SwapCacheWithCallback(
host_id, swap_cache_callback_.get(), NULL);
} else {
NOTREACHED();
}
return bool_result_;
}
void GetStatusCallback(appcache::Status status, void* param) {
status_result_ = status;
event_.Signal();
}
void StartUpdateCallback(bool result, void* param) {
bool_result_ = result;
event_.Signal();
}
void SwapCacheCallback(bool result, void* param) {
bool_result_ = result;
event_.Signal();
}
void SignalEvent() {
event_.Signal();
}
private:
friend class base::RefCountedThreadSafe<BrowserBackendProxy>;
~BrowserBackendProxy() {}
BrowserAppCacheSystem* system_;
base::WaitableEvent event_;
bool bool_result_;
appcache::Status status_result_;
scoped_ptr<appcache::GetStatusCallback> get_status_callback_;
scoped_ptr<appcache::StartUpdateCallback> start_update_callback_;
scoped_ptr<appcache::SwapCacheCallback> swap_cache_callback_;
};
// BrowserAppCacheSystem --------------------------------------------------------
// This class only works for a single process browser.
static const int kSingleProcessId = 1;
// A not so thread safe singleton, but should work for test_shell.
BrowserAppCacheSystem* BrowserAppCacheSystem::instance_ = NULL;
BrowserAppCacheSystem::BrowserAppCacheSystem()
: io_message_loop_(NULL), ui_message_loop_(NULL),
ALLOW_THIS_IN_INITIALIZER_LIST(
backend_proxy_(new BrowserBackendProxy(this))),
ALLOW_THIS_IN_INITIALIZER_LIST(
frontend_proxy_(new BrowserFrontendProxy(this))),
backend_impl_(NULL), service_(NULL), db_thread_("AppCacheDBThread"),
thread_provider_(NULL) {
DCHECK(!instance_);
instance_ = this;
}
static void SignalEvent(base::WaitableEvent* event) {
event->Signal();
}
BrowserAppCacheSystem::~BrowserAppCacheSystem() {
DCHECK(!io_message_loop_ && !backend_impl_ && !service_);
frontend_proxy_->clear_appcache_system(); // in case a task is in transit
instance_ = NULL;
if (db_thread_.IsRunning()) {
// We pump a task thru the db thread to ensure any tasks previously
// scheduled on that thread have been performed prior to return.
base::WaitableEvent event(false, false);
db_thread_.message_loop()->PostTask(FROM_HERE,
NewRunnableFunction(&SignalEvent, &event));
event.Wait();
}
}
void BrowserAppCacheSystem::InitOnUIThread(const FilePath& cache_directory) {
DCHECK(!ui_message_loop_);
AppCacheThread::Init(DB_THREAD_ID, IO_THREAD_ID);
ui_message_loop_ = MessageLoop::current();
cache_directory_ = cache_directory;
}
void BrowserAppCacheSystem::InitOnIOThread(URLRequestContext* request_context) {
if (!is_initailized_on_ui_thread())
return;
DCHECK(!io_message_loop_);
io_message_loop_ = MessageLoop::current();
io_message_loop_->AddDestructionObserver(this);
if (!db_thread_.IsRunning())
db_thread_.Start();
// Recreate and initialize per each IO thread.
service_ = new appcache::AppCacheService();
backend_impl_ = new appcache::AppCacheBackendImpl();
service_->Initialize(cache_directory_,
BrowserResourceLoaderBridge::GetCacheThread());
service_->set_request_context(request_context);
backend_impl_->Initialize(service_, frontend_proxy_.get(), kSingleProcessId);
AppCacheInterceptor::EnsureRegistered();
}
WebApplicationCacheHost* BrowserAppCacheSystem::CreateCacheHostForWebKit(
WebApplicationCacheHostClient* client) {
if (!is_initailized_on_ui_thread())
return NULL;
DCHECK(is_ui_thread());
if (!is_initialized())
return NULL;
return new WebApplicationCacheHostImpl(client, backend_proxy_.get());
}
void BrowserAppCacheSystem::SetExtraRequestBits(
URLRequest* request, int host_id, ResourceType::Type resource_type) {
if (is_initialized()) {
DCHECK(is_io_thread());
AppCacheInterceptor::SetExtraRequestInfo(
request, service_, kSingleProcessId, host_id, resource_type);
}
}
void BrowserAppCacheSystem::GetExtraResponseBits(
URLRequest* request, int64* cache_id, GURL* manifest_url) {
if (is_initialized()) {
DCHECK(is_io_thread());
AppCacheInterceptor::GetExtraResponseInfo(
request, cache_id, manifest_url);
}
}
void BrowserAppCacheSystem::WillDestroyCurrentMessageLoop() {
DCHECK(is_io_thread());
delete backend_impl_;
delete service_;
backend_impl_ = NULL;
service_ = NULL;
io_message_loop_ = NULL;
// Just in case the main thread is waiting on it.
backend_proxy_->SignalEvent();
}

7
libcef/browser_database_system.cc
View File

@ -4,17 +4,12 @@
#include "browser_database_system.h"
#if defined(USE_SYSTEM_SQLITE)
#include <sqlite3.h>
#else
#include "third_party/sqlite/preprocessed/sqlite3.h"
#endif
#include "base/auto_reset.h"
#include "base/file_util.h"
#include "base/message_loop.h"
#include "base/platform_thread.h"
#include "base/process_util.h"
#include "third_party/sqlite/preprocessed/sqlite3.h"
#include "third_party/WebKit/WebKit/chromium/public/WebDatabase.h"
#include "third_party/WebKit/WebKit/chromium/public/WebString.h"
#include "webkit/database/database_util.h"

6
libcef/browser_impl.cc
View File

@ -917,10 +917,8 @@ void CefBrowserImpl::UIT_Find(int identifier, const std::wstring& search_text,
// Just navigate back/forward.
delegate->SelectFindResult(options.forward);
} else {
if (delegate->SupportsFind()) {
delegate->StartFind(UTF16ToUTF8(search_text),
options.matchCase,
identifier);
if (delegate->StartFind(search_text.c_str(), options.matchCase,
identifier)) {
} else {
// No find results.
UIT_NotifyFindStatus(identifier, 0, gfx::Rect(), 0, true);

6
libcef/browser_impl_win.cc
View File

@ -54,10 +54,6 @@ LRESULT CALLBACK CefBrowserImpl::WndProc(HWND hwnd, UINT message,
}
browser->GetWebViewDelegate()->RevokeDragDrop();
// Call GC twice to clean up garbage.
browser->GetWebView()->mainFrame()->collectGarbage();
browser->GetWebView()->mainFrame()->collectGarbage();
// Clean up anything associated with the WebViewHost widget.
browser->GetWebViewHost()->webwidget()->close();
@ -129,7 +125,7 @@ void CefBrowserImpl::UIT_CreateBrowser(const std::wstring& url)
// Create the webview host object
webviewhost_.reset(
WebViewHost::Create(window_info_.m_hWnd, delegate_.get(),
WebViewHost::Create(window_info_.m_hWnd, delegate_.get(), NULL,
*_Context->web_preferences()));
delegate_->RegisterDragDrop();

13
libcef/browser_request_context.cc
View File

@ -43,9 +43,11 @@ void BrowserRequestContext::Init(
// Use the system proxy settings.
scoped_ptr<net::ProxyConfigService> proxy_config_service(
net::ProxyService::CreateSystemProxyConfigService(NULL, NULL));
host_resolver_ = net::CreateSystemHostResolver(NULL);
proxy_service_ = net::ProxyService::Create(proxy_config_service.release(),
net::ProxyService::CreateSystemProxyConfigService(
MessageLoop::current(), NULL));
host_resolver_ =
net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism);
proxy_service_ = net::ProxyService::Create(proxy_config_service.release(),
false, NULL, NULL, NULL, NULL);
ssl_config_service_ = net::SSLConfigService::CreateSystemSSLConfigService();
@ -56,9 +58,8 @@ void BrowserRequestContext::Init(
cache_path, 0, BrowserResourceLoaderBridge::GetCacheThread());
net::HttpCache* cache =
new net::HttpCache(NULL, host_resolver_, proxy_service_,
ssl_config_service_, http_auth_handler_factory_,
NULL, NULL, backend);
new net::HttpCache(host_resolver_, proxy_service_, ssl_config_service_,
http_auth_handler_factory_, NULL, NULL, backend);
cache->set_mode(cache_mode);
http_transaction_factory_ = cache;

19
libcef/browser_webkit_glue.cc
View File

@ -73,8 +73,8 @@ bool IsProtocolSupportedForMedia(const GURL& url) {
return false;
}
std::wstring GetWebKitLocale() {
return L"en-US";
std::string GetWebKitLocale() {
return "en-US";
}
void InitializeTextEncoding() {
@ -111,5 +111,20 @@ std::string GetProductVersion() {
return std::string("CEF/0.0.0.0");
}
bool IsSingleProcess() {
return true;
}
#if defined(OS_LINUX)
int MatchFontWithFallback(const std::string& face, bool bold,
bool italic, int charset) {
return -1;
}
bool GetFontTable(int fd, uint32_t table, uint8_t* output,
size_t* output_length) {
return false;
}
#endif
} // namespace webkit_glue

2
libcef/browser_webkit_glue_win.cc
View File

@ -87,7 +87,7 @@ void CaptureWebViewBitmap(HWND mainWnd, WebView* webview, HBITMAP& bitmap,
skia::PlatformCanvas canvas(size.cx, size.cy, true);
canvas.drawARGB(255, 255, 255, 255, SkXfermode::kSrc_Mode);
PlatformContextSkia context(&canvas);
WebCore::PlatformContextSkia context(&canvas);
WebKit::WebRect rect(0, 0, size.cx, size.cy);
webview->layout();
webview->paint(&canvas, rect);

11
libcef/browser_webkit_init.h
View File

@ -24,7 +24,7 @@
#include "third_party/WebKit/WebKit/chromium/public/WebSecurityPolicy.h"
#include "third_party/WebKit/WebKit/chromium/public/WebStorageArea.h"
#include "third_party/WebKit/WebKit/chromium/public/WebStorageEventDispatcher.h"
#include "third_party/WebKit/WebKit/chromium/public/WebIndexedDatabase.h"
#include "third_party/WebKit/WebKit/chromium/public/WebIDBFactory.h"
#include "third_party/WebKit/WebKit/chromium/public/WebStorageNamespace.h"
#include "third_party/WebKit/WebKit/chromium/public/WebString.h"
#include "webkit/glue/simple_webmimeregistry_impl.h"
@ -58,6 +58,11 @@ class BrowserWebKitInit : public webkit_glue::WebKitClientImpl {
WebKit::WebRuntimeFeatures::enableTouch(true);
WebKit::WebRuntimeFeatures::enableIndexedDatabase(true);
WebKit::WebRuntimeFeatures::enableGeolocation(false);
WebKit::WebRuntimeFeatures::enableSpeechInput(true);
// TODO(hwennborg): Enable this once the implementation supports it.
WebKit::WebRuntimeFeatures::enableDeviceMotion(false);
WebKit::WebRuntimeFeatures::enableDeviceOrientation(false);
// Load libraries for media and enable the media player.
FilePath module_path;
@ -178,8 +183,8 @@ class BrowserWebKitInit : public webkit_glue::WebKitClientImpl {
WebKit::WebStorageNamespace::m_localStorageQuota);
}
virtual WebKit::WebIndexedDatabase* indexedDatabase() {
return WebKit::WebIndexedDatabase::create();
virtual WebKit::WebIDBFactory* idbFactory() {
return WebKit::WebIDBFactory::create();
}
private:

7
libcef/browser_webview_delegate.cc
View File

@ -16,13 +16,14 @@
#include "v8_impl.h"
#include "base/file_util.h"
#include "gfx/point.h"
#include "base/message_loop.h"
#include "base/process_util.h"
#include "base/string_util.h"
#include "base/trace_event.h"
#include "base/utf_string_conversions.h"
#include "gfx/gdi_util.h"
#include "gfx/native_widget_types.h"
#include "gfx/point.h"
#include "net/base/net_errors.h"
#include "third_party/WebKit/WebKit/chromium/public/WebConsoleMessage.h"
#include "third_party/WebKit/WebKit/chromium/public/WebContextMenuData.h"
@ -663,8 +664,8 @@ void BrowserWebViewDelegate::didFailProvisionalLoad(
if(rv == RV_HANDLED && !error_str.empty())
error_text = WideToUTF8(error_str);
} else {
error_text = StringPrintf("Error %d when loading url %s", error.reason,
failed_ds->request().url().spec().data());
error_text = StringPrintf("Error %d when loading url %s",
error.reason, failed_ds->request().url().spec().data());
}
// Make sure we never show errors in view source mode.

5
libcef/cef_process_ui_thread.cc
View File

@ -15,6 +15,7 @@
#include "base/i18n/icu_util.h"
#include "base/rand_util.h"
#include "base/stats_table.h"
#include "base/string_number_conversions.h"
#include "build/build_config.h"
#include "net/base/net_module.h"
#if defined(OS_WIN)
@ -108,13 +109,13 @@ void CefProcessUIThread::Init() {
// Load and initialize the stats table. Attempt to construct a somewhat
// unique name to isolate separate instances from each other.
statstable_ = new StatsTable(
kStatsFilePrefix + Uint64ToString(base::RandUint64()),
kStatsFilePrefix + base::Uint64ToString(base::RandUint64()),
kStatsFileThreads,
kStatsFileCounters);
StatsTable::set_current(statstable_);
// CEF always exposes the GC.
webkit_glue::SetJavaScriptFlags(L"--expose-gc");
webkit_glue::SetJavaScriptFlags("--expose-gc");
// Expose GCController to JavaScript.
WebKit::WebScriptController::registerExtension(
extensions_v8::GCExtension::Get());

125
libcef/simple_clipboard_impl.cc
View File

@ -1,54 +1,71 @@
// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "webkit/glue/webkit_glue.h"
#include <string>
#include "app/clipboard/clipboard.h"
#include "base/lazy_instance.h"
#include "base/string16.h"
#include "googleurl/src/gurl.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "webkit/glue/scoped_clipboard_writer_glue.h"
// Clipboard glue
void ScopedClipboardWriterGlue::WriteBitmapFromPixels(
const void* pixels, const gfx::Size& size) {
ScopedClipboardWriter::WriteBitmapFromPixels(pixels, size);
}
ScopedClipboardWriterGlue::~ScopedClipboardWriterGlue() {
}
namespace webkit_glue {
base::LazyInstance<Clipboard> clipboard(base::LINKER_INITIALIZED);
Clipboard* ClipboardGetClipboard() {
return clipboard.Pointer();
}
bool ClipboardIsFormatAvailable(const Clipboard::FormatType& format,
Clipboard::Buffer buffer) {
return ClipboardGetClipboard()->IsFormatAvailable(format, buffer);
}
void ClipboardReadText(Clipboard::Buffer buffer, string16* result) {
ClipboardGetClipboard()->ReadText(buffer, result);
}
void ClipboardReadAsciiText(Clipboard::Buffer buffer, std::string* result) {
ClipboardGetClipboard()->ReadAsciiText(buffer, result);
}
void ClipboardReadHTML(Clipboard::Buffer buffer, string16* markup, GURL* url) {
std::string url_str;
ClipboardGetClipboard()->ReadHTML(buffer, markup, url ? &url_str : NULL);
if (url)
*url = GURL(url_str);
}
} // namespace webkit_glue
// Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "webkit/glue/webkit_glue.h"
#include <string>
#include "app/clipboard/clipboard.h"
#include "base/lazy_instance.h"
#include "base/string16.h"
#include "googleurl/src/gurl.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "webkit/glue/scoped_clipboard_writer_glue.h"
// Clipboard glue
void ScopedClipboardWriterGlue::WriteBitmapFromPixels(
const void* pixels, const gfx::Size& size) {
ScopedClipboardWriter::WriteBitmapFromPixels(pixels, size);
}
ScopedClipboardWriterGlue::~ScopedClipboardWriterGlue() {
}
namespace webkit_glue {
base::LazyInstance<Clipboard> clipboard(base::LINKER_INITIALIZED);
Clipboard* ClipboardGetClipboard() {
return clipboard.Pointer();
}
bool ClipboardIsFormatAvailable(const Clipboard::FormatType& format,
Clipboard::Buffer buffer) {
return ClipboardGetClipboard()->IsFormatAvailable(format, buffer);
}
void ClipboardReadText(Clipboard::Buffer buffer, string16* result) {
ClipboardGetClipboard()->ReadText(buffer, result);
}
void ClipboardReadAsciiText(Clipboard::Buffer buffer, std::string* result) {
ClipboardGetClipboard()->ReadAsciiText(buffer, result);
}
void ClipboardReadHTML(Clipboard::Buffer buffer, string16* markup, GURL* url) {
std::string url_str;
ClipboardGetClipboard()->ReadHTML(buffer, markup, url ? &url_str : NULL);
if (url)
*url = GURL(url_str);
}
// TODO(dcheng): Implement.
bool ClipboardReadAvailableTypes(Clipboard::Buffer buffer,
std::vector<string16>* types,
bool* contains_filenames) {
return false;
}
bool ClipboardReadData(Clipboard::Buffer buffer, const string16& type,
string16* data, string16* metadata) {
return false;
}
bool ClipboardReadFilenames(Clipboard::Buffer buffer,
std::vector<string16>* filenames) {
return false;
}
} // namespace webkit_glue

3
libcef/webview_host.cc
View File

@ -18,6 +18,7 @@ static const wchar_t kWindowClassName[] = L"WebViewHost";
/*static*/
WebViewHost* WebViewHost::Create(HWND parent_view,
BrowserWebViewDelegate* delegate,
WebDevToolsAgentClient* dev_tools_client,
const WebPreferences& prefs) {
WebViewHost* host = new WebViewHost();
@ -40,7 +41,7 @@ WebViewHost* WebViewHost::Create(HWND parent_view,
GetModuleHandle(NULL), NULL);
win_util::SetWindowUserData(host->view_, host);
host->webwidget_ = WebView::create(delegate);
host->webwidget_ = WebView::create(delegate, dev_tools_client);
prefs.Apply(host->webview());
host->webview()->initializeMainFrame(delegate);

2
libcef/webview_host.h
View File

@ -14,6 +14,7 @@ struct WebPreferences;
class BrowserWebViewDelegate;
namespace WebKit {
class WebDevToolsAgentClient;
class WebView;
}
@ -25,6 +26,7 @@ class WebViewHost : public WebWidgetHost {
// MoveWindow (or equivalent) function.
static WebViewHost* Create(gfx::NativeView parent_window,
BrowserWebViewDelegate* delegate,
WebKit::WebDevToolsAgentClient* devtools_client,
const WebPreferences& prefs);
WebKit::WebView* webview() const;

6
patch/patches/build.patch
View File

@ -1,8 +1,8 @@
Index: common.gypi
===================================================================
--- common.gypi (revision 50325)
--- common.gypi (revision 55388)
+++ common.gypi (working copy)
@@ -18,6 +18,9 @@
@@ -23,6 +23,9 @@
# Variables expected to be overriden on the GYP command line (-D) or by
# ~/.gyp/include.gypi.
@ -14,7 +14,7 @@ Index: common.gypi
# variables within the outer variables dict here. This is necessary
Index: win/system.gyp
===================================================================
--- win/system.gyp (revision 50325)
--- win/system.gyp (revision 55388)
+++ win/system.gyp (working copy)
@@ -22,6 +22,13 @@
'action': ['', '<@(_inputs)'],