bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-02-23 07:27:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add initial Linux support (issue #40).

Browse Source 
git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@338 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt 2011-10-24 20:20:52 +00:00
parent becadcfd16
commit 7a91ff899f
25 changed files with 986 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
cef.gyp
View File

@ -4,6 +4,7 @@
{
'variables': {
'pkg-config': 'pkg-config',
'chromium_code': 1,
'repack_locales_cmd': ['python', 'tools/repack_locales.py'],
'grit_out_dir': '<(SHARED_INTERMEDIATE_DIR)/cef',
@ -211,6 +212,67 @@
'<@(includes_linux)',
'<@(cefclient_sources_linux)',
],
'variables': {
'repack_path': '../tools/grit/grit/format/repack.py',
},
'actions': [
{
'action_name': 'repack_locales',
'inputs': [
'tools/repack_locales.py',
# NOTE: Ideally the common command args would be shared
# amongst inputs/outputs/action, but the args include shell
# variables which need to be passed intact, and command
# expansion wants to expand the shell variables. Adding the
# explicit quoting here was the only way it seemed to work.
'>!@(<(repack_locales_cmd) -i -g \'<(grit_out_dir)\' -s \'<(SHARED_INTERMEDIATE_DIR)\' -x \'<(INTERMEDIATE_DIR)\' <(locales))',
],
'outputs': [
'>!@(<(repack_locales_cmd) -o -g \'<(grit_out_dir)\' -s \'<(SHARED_INTERMEDIATE_DIR)\' -x \'<(INTERMEDIATE_DIR)\' <(locales))',
],
'action': [
'<@(repack_locales_cmd)',
'-g', '<(grit_out_dir)',
'-s', '<(SHARED_INTERMEDIATE_DIR)',
'-x', '<(INTERMEDIATE_DIR)',
'<@(locales)',
],
},
{
'action_name': 'repack_resources',
'variables': {
'pak_inputs': [
'<(grit_out_dir)/devtools_resources.pak',
'<(SHARED_INTERMEDIATE_DIR)/net/net_resources.pak',
'<(SHARED_INTERMEDIATE_DIR)/ui/gfx/gfx_resources.pak',
'<(SHARED_INTERMEDIATE_DIR)/webkit/webkit_chromium_resources.pak',
'<(SHARED_INTERMEDIATE_DIR)/webkit/webkit_resources.pak',
],
},
'inputs': [
'<(repack_path)',
'<@(pak_inputs)',
],
'outputs': [
'<(INTERMEDIATE_DIR)/repack/chrome.pak',
],
'action': ['python', '<(repack_path)', '<@(_outputs)', '<@(pak_inputs)'],
},
],
'copies': [
{
'destination': '<(PRODUCT_DIR)/locales',
'files': [
'<!@pymod_do_main(repack_locales -o -g <(grit_out_dir) -s <(SHARED_INTERMEDIATE_DIR) -x <(INTERMEDIATE_DIR) <(locales))'
],
},
{
'destination': '<(PRODUCT_DIR)',
'files': [
'<(INTERMEDIATE_DIR)/repack/chrome.pak'
],
},
],
}],
],
},
@ -437,6 +499,24 @@
],
},
}],
[ 'OS=="linux" or OS=="freebsd" or OS=="openbsd"', {
'dependencies':[
'../base/allocator/allocator.gyp:allocator',
],
'direct_dependent_settings': {
'cflags': [
'<!@(<(pkg-config) --cflags gtk+-2.0 gthread-2.0)',
],
},
'link_settings': {
'ldflags': [
'<!@(<(pkg-config) --libs-only-L --libs-only-other gtk+-2.0 gthread-2.0)',
],
'libraries': [
'<!@(<(pkg-config) --libs-only-l gtk+-2.0 gthread-2.0)',
],
},
}],
],
},
{

2
cef_paths.gypi
View File

@ -110,6 +110,8 @@
],
'cefclient_sources_linux': [
'tests/cefclient/cefclient_gtk.cpp',
'tests/cefclient/client_handler_gtk.cpp',
'tests/cefclient/resource_util_linux.cpp',
],
'libcef_dll_wrapper_sources_common': [
'libcef_dll/cef_logging.h',

2
include/cef_capi.h
View File

@ -373,7 +373,7 @@ typedef struct _cef_base_t
// Check that the structure |s|, which is defined with a cef_base_t member named
// |base|, is large enough to contain the specified member |f|.
#define CEF_MEMBER_EXISTS(s, f) \
((int)&((s)->f) - (int)(s) + sizeof((s)->f) <= (s)->base.size)
((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= (s)->base.size)
#define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f))

2
libcef/browser_impl.cc
View File

@ -1111,6 +1111,7 @@ CefRefPtr<CefBrowserImpl> CefBrowserImpl::UIT_CreatePopupWindow(
info.SetAsPopup(NULL, CefString());
#endif
#if (defined(OS_WIN) || defined(OS_MACOSX))
// Default to the size from the popup features.
if(features.xSet)
info.m_x = features.x;
@ -1120,6 +1121,7 @@ CefRefPtr<CefBrowserImpl> CefBrowserImpl::UIT_CreatePopupWindow(
info.m_nWidth = features.width;
if(features.heightSet)
info.m_nHeight = features.height;
#endif
CefRefPtr<CefClient> client = client_;

79
libcef/browser_impl_gtk.cc
View File

@ -35,11 +35,9 @@ bool CefBrowserImpl::IsWindowRenderingDisabled()
return false;
}
gfx::NativeWindow CefBrowserImpl::UIT_GetMainWndHandle() {
gfx::NativeView CefBrowserImpl::UIT_GetMainWndHandle() {
REQUIRE_UIT();
GtkWidget* toplevel = gtk_widget_get_ancestor(window_info_.m_Widget,
GTK_TYPE_WINDOW);
return GTK_IS_WINDOW(toplevel) ? GTK_WINDOW(toplevel) : NULL;
return window_info_.m_Widget;
}
bool CefBrowserImpl::UIT_CreateBrowser(const CefString& url)
@ -56,6 +54,23 @@ bool CefBrowserImpl::UIT_CreateBrowser(const CefString& url)
if (!settings_.developer_tools_disabled)
dev_tools_agent_.reset(new BrowserDevToolsAgent());
GtkWidget *window;
GtkWidget* parentView = window_info_.m_ParentWidget;
if(parentView == NULL) {
// Create a new window.
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
parentView = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), parentView);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_widget_show_all(GTK_WIDGET(window));
window_info_.m_ParentWidget = parentView;
}
WebPreferences prefs;
BrowserToWebSettings(settings_, prefs);
@ -72,9 +87,12 @@ bool CefBrowserImpl::UIT_CreateBrowser(const CefString& url)
Unlock();
if(handler_.get()) {
if (client_.get()) {
CefRefPtr<CefLifeSpanHandler> handler = client_->GetLifeSpanHandler();
if(handler.get()) {
// Notify the handler that we're done creating the new window
handler_->HandleAfterCreated(this);
handler->OnAfterCreated(this);
}
}
if(url.size() > 0)
@ -97,9 +115,37 @@ bool CefBrowserImpl::UIT_ViewDocumentString(WebKit::WebFrame *frame)
{
REQUIRE_UIT();
// TODO(port): Add implementation.
NOTIMPLEMENTED();
char buff[] = "/tmp/CEFSourceXXXXXX";
int fd = mkstemp(buff);
if (fd == -1)
return false;
FILE* srcOutput;
srcOutput = fdopen(fd, "w+");
if (!srcOutput)
return false;
std::string markup = frame->contentAsMarkup().utf8();
if (fputs(markup.c_str(), srcOutput) < 0) {
fclose(srcOutput);
return false;
}
fclose(srcOutput);
std::string newName(buff);
newName.append(".txt");
if (rename(buff, newName.c_str()) != 0)
return false;
std::string openCommand("xdg-open ");
openCommand += newName;
if (system(openCommand.c_str()) != 0)
return false;
return true;
}
void CefBrowserImpl::UIT_PrintPage(int page_number, int total_pages,
@ -130,6 +176,21 @@ int CefBrowserImpl::UIT_GetPagesCount(WebKit::WebFrame* frame)
// static
void CefBrowserImpl::UIT_CloseView(gfx::NativeView view)
{
GtkWidget* window =
gtk_widget_get_parent(gtk_widget_get_parent(GTK_WIDGET(view)));
MessageLoop::current()->PostTask(FROM_HERE, NewRunnableFunction(
&gtk_widget_destroy, GTK_WIDGET(view)));
&gtk_widget_destroy, GTK_WIDGET(window)));
}
// static
bool CefBrowserImpl::UIT_IsViewVisible(gfx::NativeView view)
{
if (!view)
return false;
if (view->window)
return (bool)gdk_window_is_visible(view->window);
else
return false;
}

16
libcef/browser_request_context.cc
View File

@ -129,10 +129,24 @@ void BrowserRequestContext::Init(
#endif // defined(OS_WIN)
if (!proxy_service()) {
// Use the system proxy resolver.
#if defined(OS_POSIX) && !defined(OS_MACOSX)
// Use no proxy to avoid ProxyConfigServiceLinux.
// Enabling use of the ProxyConfigServiceLinux requires:
// -Calling from a thread with a TYPE_UI MessageLoop,
// -If at all possible, passing in a pointer to the IO thread's MessageLoop,
// -Keep in mind that proxy auto configuration is also
// non-functional on linux in this context because of v8 threading
// issues.
// TODO(port): rename "linux" to some nonspecific unix.
scoped_ptr<net::ProxyConfigService> proxy_config_service(
new net::ProxyConfigServiceFixed(net::ProxyConfig()));
#else
// Use the system proxy settings.
scoped_ptr<net::ProxyConfigService> proxy_config_service(
net::ProxyService::CreateSystemProxyConfigService(
MessageLoop::current(), NULL));
#endif
storage_.set_proxy_service(net::ProxyService::CreateUsingSystemProxyResolver(
proxy_config_service.release(), 0, NULL));
}

22
libcef/browser_webkit_glue_gtk.cc Normal file
View File

@ -0,0 +1,22 @@
// Copyright (c) 2008-2009 The Chromium Embedded Framework Authors.
// Portions 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 "browser_webkit_glue.h"
#include "cef_context.h"
#include "ui/base/resource/resource_bundle.h"
namespace webkit_glue {
base::StringPiece GetDataResource(int resource_id) {
base::StringPiece piece;
// Try to load the resource from the resource pack.
if (piece.empty())
piece = ResourceBundle::GetSharedInstance().GetRawDataResource(resource_id);
DCHECK(!piece.empty()) << "Resource "<<resource_id<<" could not be loaded";
return piece;
}
}

4
libcef/browser_webview_delegate.h
View File

@ -259,6 +259,10 @@ class BrowserWebViewDelegate : public WebKit::WebViewClient,
void ClosePopupMenu();
#endif
#ifdef OS_LINUX
void HandleContextMenu(int selected_id);
#endif
protected:
// Default handling of JavaScript messages.
void ShowJavaScriptAlert(WebKit::WebFrame* webframe,

170
libcef/browser_webview_delegate_gtk.cc
View File

@ -10,25 +10,41 @@
#include <gtk/gtk.h>
#include "base/message_loop.h"
#include "base/string_util.h"
#include "net/base/net_errors.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebContextMenuData.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenu.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebDragData.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebImage.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebPoint.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebRect.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/gfx/gtk_util.h"
#include "ui/gfx/point.h"
#include "webkit/glue/webcursor.h"
#include "webkit/glue/webdropdata.h"
#include "webkit/glue/webpreferences.h"
#include "webkit/glue/webkit_glue.h"
#include "webkit/glue/window_open_disposition.h"
#include "webkit/plugins/npapi/gtk_plugin_container_manager.h"
#include "webkit/plugins/npapi/plugin_list.h"
#include "webkit/plugins/npapi/webplugin.h"
#include "webkit/plugins/npapi/webplugin_delegate_impl.h"
#include "include/internal/cef_types.h"
using webkit::npapi::WebPluginDelegateImpl;
using WebKit::WebContextMenuData;
using WebKit::WebCursorInfo;
using WebKit::WebDragData;
using WebKit::WebDragOperationsMask;
using WebKit::WebExternalPopupMenu;
using WebKit::WebExternalPopupMenuClient;
using WebKit::WebFrame;
using WebKit::WebImage;
using WebKit::WebNavigationPolicy;
using WebKit::WebPoint;
using WebKit::WebPopupMenuInfo;
using WebKit::WebRect;
using WebKit::WebWidget;
@ -59,11 +75,11 @@ void SelectionClipboardGetContents(GtkClipboard* clipboard,
DCHECK(frame);
std::string selection;
if (TEXT_HTML == info) {
if (TEXT_HTML == info)
selection = frame->selectionAsMarkup().utf8();
} else {
else
selection = frame->selectionAsText().utf8();
}
if (TEXT_HTML == info) {
gtk_selection_data_set(selection_data,
GetTextHtmlAtom(),
@ -78,17 +94,112 @@ void SelectionClipboardGetContents(GtkClipboard* clipboard,
} // namespace
// WebViewClient --------------------------------------------------------------
// WebViewClient ----------------------------------s----------------------------
WebWidget* BrowserWebViewDelegate::createPopupMenu(
const WebPopupMenuInfo& info) {
NOTREACHED();
WebKit::WebExternalPopupMenu* BrowserWebViewDelegate::createExternalPopupMenu(
const WebKit::WebPopupMenuInfo& info,
WebKit::WebExternalPopupMenuClient* client) {
NOTIMPLEMENTED();
return NULL;
}
void BrowserWebViewDelegate::showContextMenu(
WebKit::WebFrame* frame, const WebKit::WebContextMenuData& data) {
NOTIMPLEMENTED();
static gboolean MenuItemHandle(GtkWidget* menu_item, gpointer data)
{
if (!data)
return FALSE;
BrowserWebViewDelegate* webViewDelegate = (BrowserWebViewDelegate*)data;
int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_item), "menu_id"));
webViewDelegate->HandleContextMenu(id);
return FALSE;
}
static GtkWidget* MenuItemCreate(GtkWidget* parent_menu, const char* name,
int id, bool is_enabled, BrowserWebViewDelegate* webViewDelegate)
{
GtkWidget* menu_item = gtk_menu_item_new_with_label(name);
g_object_set_data(G_OBJECT(menu_item), "menu_id", (gpointer)id);
g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(MenuItemHandle),
(gpointer)webViewDelegate);
gtk_menu_shell_append(GTK_MENU_SHELL(parent_menu), menu_item);
gtk_widget_set_sensitive(menu_item, is_enabled);
gtk_widget_show(menu_item);
return menu_item;
}
static GtkWidget* MenuItemCreateSeperator(GtkWidget* parent_menu)
{
GtkWidget* menu_item = gtk_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(parent_menu), menu_item);
gtk_widget_show(menu_item);
return menu_item;
}
void BrowserWebViewDelegate::showContextMenu(WebKit::WebFrame* frame,
const WebKit::WebContextMenuData& data) {
GtkWidget* menu = NULL;
GdkPoint mouse_pt = { data.mousePosition.x, data.mousePosition.y };
int edit_flags = 0;
int type_flags = 0;
// Make sure events can be pumped while the menu is up.
MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
// Give the client a chance to handle the menu.
if (OnBeforeMenu(data, mouse_pt.x, mouse_pt.y, edit_flags, type_flags))
return;
CefRefPtr<CefClient> client = browser_->GetClient();
CefRefPtr<CefMenuHandler> handler;
if (client.get())
handler = client->GetMenuHandler();
// Build the correct default context menu
if (type_flags & MENUTYPE_EDITABLE) {
menu = gtk_menu_new();
MenuItemCreate(menu, "Undo", MENU_ID_UNDO,
!!(edit_flags & MENU_CAN_UNDO), this);
MenuItemCreate(menu, "Redo", MENU_ID_REDO,
!!(edit_flags & MENU_CAN_REDO), this);
MenuItemCreate(menu, "Cut", MENU_ID_CUT,
!!(edit_flags & MENU_CAN_CUT), this);
MenuItemCreate(menu, "Copy", MENU_ID_COPY,
!!(edit_flags & MENU_CAN_COPY), this);
MenuItemCreate(menu, "Paste", MENU_ID_PASTE,
!!(edit_flags & MENU_CAN_PASTE), this);
MenuItemCreate(menu, "Delete", MENU_ID_DELETE,
!!(edit_flags & MENU_CAN_DELETE), this);
MenuItemCreateSeperator(menu);
MenuItemCreate(menu, "Select All", MENU_ID_SELECTALL,
!!(edit_flags & MENU_CAN_SELECT_ALL), this);
} else if(type_flags & MENUTYPE_SELECTION) {
menu = gtk_menu_new();
MenuItemCreate(menu, "Copy", MENU_ID_COPY,
!!(edit_flags & MENU_CAN_COPY), this);
} else if(type_flags & (MENUTYPE_PAGE | MENUTYPE_FRAME)) {
menu = gtk_menu_new();
MenuItemCreate(menu, "Back", MENU_ID_NAV_BACK,
!!(edit_flags & MENU_CAN_GO_BACK), this);
MenuItemCreate(menu, "Forward", MENU_ID_NAV_FORWARD,
!!(edit_flags & MENU_CAN_GO_FORWARD), this);
MenuItemCreateSeperator(menu);
// TODO(port): Enable the print item when supported.
// MenuItemCreate(menu, "Print", MENU_ID_PRINT, true, this);
MenuItemCreate(menu, "View Source", MENU_ID_VIEWSOURCE, true, this);
}
if (menu) {
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3,
gtk_get_current_event_time());
}
}
// WebWidgetClient ------------------------------------------------------------
@ -123,7 +234,8 @@ void BrowserWebViewDelegate::didChangeCursor(const WebCursorInfo& cursor_info) {
gdk_cursor = gfx::GetCursor(cursor_type);
}
cursor_type_ = cursor_type;
gdk_window_set_cursor(browser_->UIT_GetWebViewWndHandle()->window, gdk_cursor);
gdk_window_set_cursor(browser_->UIT_GetWebViewWndHandle()->window,
gdk_cursor);
}
WebRect BrowserWebViewDelegate::windowRect() {
@ -161,9 +273,9 @@ WebRect BrowserWebViewDelegate::rootWindowRect() {
// window. This means the x/y is the distance from the corner of the
// screen, and the width/height is the size of the entire browser window.
// For example, this is used to implement window.screenX and window.screenY.
GtkWidget* drawing_area = host->view_handle();
GtkWidget* window =
gtk_widget_get_parent(gtk_widget_get_parent(drawing_area));
GtkWidget* window = gtk_widget_get_ancestor(GTK_WIDGET(host->view_handle()),
GTK_TYPE_WINDOW);
gint x, y, width, height;
gtk_window_get_position(GTK_WINDOW(window), &x, &y);
gtk_window_get_size(GTK_WINDOW(window), &width, &height);
@ -222,6 +334,30 @@ void BrowserWebViewDelegate::DidMovePlugin(
plugin_container_manager->MovePluginContainer(move);
}
void BrowserWebViewDelegate::HandleContextMenu(int selected_id)
{
if (selected_id != 0) {
CefRefPtr<CefClient> client = browser_->GetClient();
CefRefPtr<CefMenuHandler> handler;
if (client.get())
handler = client->GetMenuHandler();
// An action was chosen
cef_handler_menuid_t menuId =
static_cast<cef_handler_menuid_t>(selected_id);
bool handled = false;
if (handler.get()) {
// Ask the handler if it wants to handle the action
handled = handler->OnMenuAction(browser_, menuId);
}
if(!handled) {
// Execute the action
browser_->UIT_HandleAction(menuId, browser_->GetFocusedFrame());
}
}
}
// Protected methods ----------------------------------------------------------
void BrowserWebViewDelegate::ShowJavaScriptAlert(

6
libcef/cef_string_map.cc
View File

@ -30,7 +30,7 @@ CEF_EXPORT int cef_string_map_find(cef_string_map_t map,
StringMap* impl = (StringMap*)map;
StringMap::const_iterator it = impl->find(CefString(key));
if(it == impl->end())
return NULL;
return 0;
const CefString& val = it->second;
return cef_string_set(val.c_str(), val.length(), value, true);
}
@ -43,7 +43,7 @@ CEF_EXPORT int cef_string_map_key(cef_string_map_t map, int index,
StringMap* impl = (StringMap*)map;
DCHECK(index >= 0 && index < (int)impl->size());
if(index < 0 || index >= (int)impl->size())
return NULL;
return 0;
StringMap::const_iterator it = impl->begin();
for(int ct = 0; it != impl->end(); ++it, ct++) {
if(ct == index)
@ -60,7 +60,7 @@ CEF_EXPORT int cef_string_map_value(cef_string_map_t map, int index,
StringMap* impl = (StringMap*)map;
DCHECK(index >= 0 && index < (int)impl->size());
if(index < 0 || index >= (int)impl->size())
return NULL;
return 0;
StringMap::const_iterator it = impl->begin();
for(int ct = 0; it != impl->end(); ++it, ct++) {
if(ct == index) {

2
libcef/scheme_impl.cc
View File

@ -303,7 +303,7 @@ private:
job_->NotifyReadComplete(bytes_read);
dest_ = NULL;
dest_size_ = NULL;
dest_size_ = 0;
}
} else {
// All done.

2
libcef/webwidget_host.cc
View File

@ -73,7 +73,7 @@ gfx::PluginWindowHandle WebWidgetHost::GetWindowedPluginAt(int x, int y)
}
}
return NULL;
return gfx::kNullPluginWindow;
}
void WebWidgetHost::DoPaint() {

6
libcef/webwidget_host_gtk.cc
View File

@ -227,6 +227,9 @@ class WebWidgetHostGtkWidget {
return FALSE; // We do not forward any other buttons to the renderer.
if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS)
return FALSE;
gtk_widget_grab_focus(widget);
host->webwidget()->handleInputEvent(
WebInputEventFactory::mouseEvent(event));
return FALSE;
@ -346,7 +349,8 @@ WebWidgetHost::~WebWidgetHost() {
g_object_set_data(G_OBJECT(view_), kWebWidgetHostKey, NULL);
g_signal_handlers_disconnect_matched(view_,
G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, this);
webwidget_->close();
// TODO(port): Figure out why we can't do this without crashing.
// webwidget_->close();
}
void WebWidgetHost::Resize(const gfx::Size &newsize) {

6
libcef_dll/cpptoc/domdocument_cpptoc.cc
View File

@ -110,7 +110,7 @@ int CEF_CALLBACK domdocument_has_selection(struct _cef_domdocument_t* self)
{
DCHECK(self);
if(!self)
return NULL;
return 0;
return CefDOMDocumentCppToC::Get(self)->HasSelection();
}
@ -134,7 +134,7 @@ int CEF_CALLBACK domdocument_get_selection_start_offset(
{
DCHECK(self);
if(!self)
return NULL;
return 0;
return CefDOMDocumentCppToC::Get(self)->GetSelectionStartOffset();
}
@ -158,7 +158,7 @@ int CEF_CALLBACK domdocument_get_selection_end_offset(
{
DCHECK(self);
if(!self)
return NULL;
return 0;
return CefDOMDocumentCppToC::Get(self)->GetSelectionEndOffset();
}

419
tests/cefclient/cefclient_gtk.cpp Normal file
View File

@ -0,0 +1,419 @@
#include "include/cef.h"
#include "cefclient.h"
#include "client_handler.h"
#include "binding_test.h"
#include "extension_test.h"
#include "scheme_test.h"
#include <gtk/gtk.h>
#include <stdlib.h>
#include <unistd.h>
#include "string_util.h"
#include <iostream>
using namespace std;
char szWorkingDir[512]; // The current working directory
// The global ClientHandler reference.
extern CefRefPtr<ClientHandler> g_handler;
void destroy(void) {
CefShutdown();
exit(0);
}
void TerminationSignalHandler(int signatl) {
CefShutdown();
exit(0);
}
// Callback for Debug > Get Source... menu item.
gboolean GetSourceActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunGetSourceTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > Get Source... menu item.
gboolean GetTextActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunGetTextTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > JS Binding... menu item.
gboolean JSBindngActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunBindingTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > JS Extension... menu item.
gboolean JSExtensionActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunExtensionTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > JS Execute... menu item.
gboolean JSExecuteActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunJavaScriptExecuteTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > Request... menu item.
gboolean RequestActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunRequestTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > Local Storage... menu item.
gboolean LocalStorageActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunLocalStorageTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > XMLHttpRequest... menu item.
gboolean XMLHttpRequestActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunXMLHTTPRequestTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > WebURLRequest... menu item.
gboolean WebURLRequestActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunWebURLRequestTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > DOM Access... menu item.
gboolean DOMAccessActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunDOMAccessTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > Scheme Handler... menu item.
gboolean SchemeHandlerActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunSchemeTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > Popup Window... menu item.
gboolean PopupWindowActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunPopupTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > Accelerated 2D Canvas:... menu item.
gboolean Accelerated2DCanvasActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunAccelerated2DCanvasTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > Accelerated Layers:... menu item.
gboolean AcceleratedLayersActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunAcceleratedLayersTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > WebGL:... menu item.
gboolean WebGLActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunWebGLTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > HTML5 Video... menu item.
gboolean HTML5VideoActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd())
RunHTML5VideoTest(g_handler->GetBrowser());
return FALSE; // Don't stop this message.
}
// Callback for Debug > Zoom In... menu item.
gboolean ZoomInActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd()) {
CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
browser->SetZoomLevel(browser->GetZoomLevel() + 0.5);
}
return FALSE; // Don't stop this message.
}
// Callback for Debug > Zoom Out... menu item.
gboolean ZoomOutActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd()) {
CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
browser->SetZoomLevel(browser->GetZoomLevel() - 0.5);
}
return FALSE; // Don't stop this message.
}
// Callback for Debug > Zoom Reset... menu item.
gboolean ZoomResetActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd()) {
CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
browser->SetZoomLevel(0.0);
}
return FALSE; // Don't stop this message.
}
gboolean DragDropActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd()) {
CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
RunDragDropTest(browser);
}
return FALSE; // Don't stop this message.
}
gboolean ShowDevtoolsActivated(GtkWidget* widget) {
if(g_handler.get() && g_handler->GetBrowserHwnd()) {
CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
browser->ShowDevTools();
}
return FALSE; // Don't stop this message.
}
// Callback for when you click the back button.
void BackButtonClicked(GtkButton* button) {
if (g_handler.get() && g_handler->GetBrowserHwnd())
g_handler->GetBrowser()->GoBack();
}
// Callback for when you click the forward button.
void ForwardButtonClicked(GtkButton* button) {
if (g_handler.get() && g_handler->GetBrowserHwnd())
g_handler->GetBrowser()->GoForward();
}
// Callback for when you click the stop button.
void StopButtonClicked(GtkButton* button) {
if (g_handler.get() && g_handler->GetBrowserHwnd())
g_handler->GetBrowser()->StopLoad();
}
// Callback for when you click the reload button.
void ReloadButtonClicked(GtkButton* button) {
if (g_handler.get() && g_handler->GetBrowserHwnd())
g_handler->GetBrowser()->Reload();
}
// Callback for when you press enter in the URL box.
void URLEntryActivate(GtkEntry* entry) {
if (!g_handler.get() || !g_handler->GetBrowserHwnd())
return;
const gchar* url = gtk_entry_get_text(entry);
g_handler->GetBrowser()->GetMainFrame()->LoadURL(std::string(url).c_str());
}
// GTK utility functions ----------------------------------------------
GtkWidget* AddMenuEntry(GtkWidget* menu_widget, const char* text,
GCallback callback) {
GtkWidget* entry = gtk_menu_item_new_with_label(text);
g_signal_connect(entry, "activate", callback, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_widget), entry);
return entry;
}
GtkWidget* CreateMenu(GtkWidget* menu_bar, const char* text) {
GtkWidget* menu_widget = gtk_menu_new();
GtkWidget* menu_header = gtk_menu_item_new_with_label(text);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_header), menu_widget);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), menu_header);
return menu_widget;
}
GtkWidget* CreateMenuBar() {
GtkWidget* menu_bar = gtk_menu_bar_new();
GtkWidget* debug_menu = CreateMenu(menu_bar, "Tests");
AddMenuEntry(debug_menu, "Get Source",
G_CALLBACK(GetSourceActivated));
AddMenuEntry(debug_menu, "Get Text",
G_CALLBACK(GetTextActivated));
AddMenuEntry(debug_menu, "JS Binding",
G_CALLBACK(JSBindngActivated));
AddMenuEntry(debug_menu, "JS Extension",
G_CALLBACK(JSExtensionActivated));
AddMenuEntry(debug_menu, "JS Execute",
G_CALLBACK(JSExecuteActivated));
AddMenuEntry(debug_menu, "Request",
G_CALLBACK(RequestActivated));
AddMenuEntry(debug_menu, "Local Storage",
G_CALLBACK(LocalStorageActivated));
AddMenuEntry(debug_menu, "XMLHttpRequest",
G_CALLBACK(XMLHttpRequestActivated));
AddMenuEntry(debug_menu, "DOM Access",
G_CALLBACK(DOMAccessActivated));
AddMenuEntry(debug_menu, "Scheme Handler",
G_CALLBACK(SchemeHandlerActivated));
AddMenuEntry(debug_menu, "Popup Window",
G_CALLBACK(PopupWindowActivated));
AddMenuEntry(debug_menu, "Accelerated 2D Canvas",
G_CALLBACK(Accelerated2DCanvasActivated));
AddMenuEntry(debug_menu, "Accelerated Layers",
G_CALLBACK(AcceleratedLayersActivated));
AddMenuEntry(debug_menu, "WebGL",
G_CALLBACK(WebGLActivated));
AddMenuEntry(debug_menu, "HTML5 Video",
G_CALLBACK(HTML5VideoActivated));
AddMenuEntry(debug_menu, "Zoom In",
G_CALLBACK(ZoomInActivated));
AddMenuEntry(debug_menu, "Zoom Out",
G_CALLBACK(ZoomOutActivated));
AddMenuEntry(debug_menu, "Zoom Reset",
G_CALLBACK(ZoomResetActivated));
AddMenuEntry(debug_menu, "Test DragDrop",
G_CALLBACK(DragDropActivated));
AddMenuEntry(debug_menu, "Show DevTools",
G_CALLBACK(ShowDevtoolsActivated));
return menu_bar;
}
// WebViewDelegate::TakeFocus in the test webview delegate.
static gboolean HandleFocus(GtkWidget* widget,
GdkEventFocus* focus) {
if(g_handler.get() && g_handler->GetBrowserHwnd()) {
// Give focus to the browser window.
g_handler->GetBrowser()->SetFocus(true);
}
return TRUE;
}
int main(int argc, char *argv[]) {
if(!getcwd(szWorkingDir, sizeof (szWorkingDir)))
return -1;
GtkWidget *window;
gtk_init(&argc, &argv);
CefSettings settings;
CefInitialize(settings);
// Register the V8 extension handler.
InitExtensionTest();
// Register the scheme handler.
InitSchemeTest();
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
g_signal_connect(window, "focus", G_CALLBACK(&HandleFocus), NULL);
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
GtkWidget* menu_bar = CreateMenuBar();
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0);
GtkWidget* toolbar = gtk_toolbar_new();
// Turn off the labels on the toolbar buttons.
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
GtkToolItem* back = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
g_signal_connect(back, "clicked",
G_CALLBACK(BackButtonClicked), NULL);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), back, -1 /* append */);
GtkToolItem* forward = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
g_signal_connect(forward, "clicked",
G_CALLBACK(ForwardButtonClicked), NULL);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), forward, -1 /* append */);
GtkToolItem* reload = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH);
g_signal_connect(reload, "clicked",
G_CALLBACK(ReloadButtonClicked), NULL);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), reload, -1 /* append */);
GtkToolItem* stop = gtk_tool_button_new_from_stock(GTK_STOCK_STOP);
g_signal_connect(stop, "clicked",
G_CALLBACK(StopButtonClicked), NULL);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), stop, -1 /* append */);
GtkWidget* m_editWnd = gtk_entry_new();
g_signal_connect(G_OBJECT(m_editWnd), "activate",
G_CALLBACK(URLEntryActivate), NULL);
GtkToolItem* tool_item = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(tool_item), m_editWnd);
gtk_tool_item_set_expand(tool_item, TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, -1); //append
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_widget_destroyed), &window);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(destroy), NULL);
// Create the handler.
g_handler = new ClientHandler();
g_handler->SetMainHwnd(vbox);
g_handler->SetEditHwnd(m_editWnd);
g_handler->SetButtonHwnds(GTK_WIDGET(back), GTK_WIDGET(forward),
GTK_WIDGET(reload), GTK_WIDGET(stop));
// Create the browser view.
CefWindowInfo window_info;
CefBrowserSettings browserSettings;
window_info.SetAsChild(vbox);
CefBrowser::CreateBrowserSync(window_info,
static_cast<CefRefPtr<CefClient> >(g_handler),
"http://www.google.com", browserSettings);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show_all(GTK_WIDGET(window));
// Install an signal handler so we clean up after ourselves.
signal(SIGINT, TerminationSignalHandler);
signal(SIGTERM, TerminationSignalHandler);
CefRunMessageLoop();
return 0;
}
// Global functions
std::string AppGetWorkingDirectory() {
return szWorkingDir;
}

120
tests/cefclient/client_handler_gtk.cpp Normal file
View File

@ -0,0 +1,120 @@
#include "include/cef.h"
#include "include/cef_wrapper.h"
#include "cefclient.h"
#include "client_handler.h"
#include "resource_util.h"
#include "string_util.h"
#include <gtk/gtk.h>
// ClientHandler::ClientLifeSpanHandler implementation
bool ClientHandler::OnBeforePopup(CefRefPtr<CefBrowser> parentBrowser,
const CefPopupFeatures& popupFeatures,
CefWindowInfo& windowInfo,
const CefString& url,
CefRefPtr<CefClient>& client,
CefBrowserSettings& settings)
{
REQUIRE_UI_THREAD();
return false;
}
bool ClientHandler::OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request,
CefString& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream,
CefRefPtr<CefResponse> response,
int loadFlags)
{
REQUIRE_IO_THREAD();
std::string url = request->GetURL();
if(url == "http://tests/request") {
// Show the request contents
std::string dump;
DumpRequestContents(request, dump);
resourceStream = CefStreamReader::CreateForData(
(void*)dump.c_str(), dump.size());
response->SetMimeType("text/plain");
response->SetStatus(200);
} else if (strstr(url.c_str(), "/ps_logo2.png") != NULL) {
// Any time we find "ps_logo2.png" in the URL substitute in our own image
resourceStream = GetBinaryResourceReader("logo.png");
response->SetMimeType("image/png");
response->SetStatus(200);
} else if(url == "http://tests/localstorage") {
// Show the localstorage contents
resourceStream = GetBinaryResourceReader("localstorage.html");
response->SetMimeType("text/html");
response->SetStatus(200);
} else if(url == "http://tests/xmlhttprequest") {
// Show the xmlhttprequest HTML contents
resourceStream = GetBinaryResourceReader("xmlhttprequest.html");
response->SetMimeType("text/html");
response->SetStatus(200);
} else if(url == "http://tests/domaccess") {
// Show the domaccess HTML contents
resourceStream = GetBinaryResourceReader("domaccess.html");
response->SetMimeType("text/html");
response->SetStatus(200);
}
return false;
}
void ClientHandler::OnAddressChange(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const CefString& url)
{
REQUIRE_UI_THREAD();
if(m_BrowserHwnd == browser->GetWindowHandle() && frame->IsMain()) {
// Set the edit window text
std::string urlStr(url);
gtk_entry_set_text(GTK_ENTRY(m_EditHwnd), urlStr.c_str());
}
}
void ClientHandler::OnTitleChange(CefRefPtr<CefBrowser> browser,
const CefString& title)
{
REQUIRE_UI_THREAD();
GtkWidget* window =
gtk_widget_get_ancestor(GTK_WIDGET(browser->GetWindowHandle()),
GTK_TYPE_WINDOW);
std::string titleStr(title);
gtk_window_set_title(GTK_WINDOW(window), titleStr.c_str());
}
void ClientHandler::SendNotification(NotificationType type)
{
// TODO(port): Implement this method.
}
void ClientHandler::SetLoading(bool isLoading)
{
if(isLoading)
gtk_widget_set_sensitive(GTK_WIDGET(m_StopHwnd), true);
else
gtk_widget_set_sensitive(GTK_WIDGET(m_StopHwnd), false);
}
void ClientHandler::SetNavState(bool canGoBack, bool canGoForward)
{
if(canGoBack)
gtk_widget_set_sensitive(GTK_WIDGET(m_BackHwnd), true);
else
gtk_widget_set_sensitive(GTK_WIDGET(m_BackHwnd), false);
if(canGoForward)
gtk_widget_set_sensitive(GTK_WIDGET(m_ForwardHwnd), true);
else
gtk_widget_set_sensitive(GTK_WIDGET(m_ForwardHwnd), false);
}
void ClientHandler::CloseMainWindow()
{
// TODO(port): Close main window.
}

2
tests/cefclient/resource_util.h
View File

@ -15,7 +15,7 @@
bool LoadBinaryResource(int binaryId, DWORD &dwSize, LPBYTE &pBytes);
CefRefPtr<CefStreamReader> GetBinaryResourceReader(int binaryId);
#elif defined(OS_MACOSX)
#elif (defined(OS_MACOSX) || defined(OS_POSIX))
// Load the resource with the specified name.
bool LoadBinaryResource(const char* resource_name, std::string& resource_data);

39
tests/cefclient/resource_util_linux.cpp Normal file
View File

@ -0,0 +1,39 @@
// Copyright (c) 2011 The Chromium Embedded Framework Authors.
// Portions copyright (c) 2011 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 "resource_util.h"
#include "util.h"
#include <stdio.h>
#include "base/file_util.h"
bool GetResourceDir(std::string& dir) {
char buff[1024];
ssize_t len = ::readlink("/proc/self/exe", buff, sizeof(buff)-1);
if (len != -1) {
buff[len] = '\0';
dir = std::string(buff);
return true;
} else {
/* handle error condition */
return false;
}
}
bool LoadBinaryResource(const char* resource_name, std::string& resource_data) {
return false;
}
CefRefPtr<CefStreamReader> GetBinaryResourceReader(const char* resource_name) {
std::string path;
if (!GetResourceDir(path))
return NULL;
path.append("/");
path.append(resource_name);
return CefStreamReader::CreateForFile(path);
}

4
tests/cefclient/scheme_test.cpp
View File

@ -67,12 +67,14 @@ public:
// Set the resulting mime type
mime_type_ = "image/jpg";
}
#elif defined(OS_MACOSX)
#elif (defined(OS_MACOSX) || defined(OS_LINUX))
if(LoadBinaryResource("logo.png", data_)) {
handled = true;
// Set the resulting mime type
mime_type_ = "image/png";
}
#else
#error "Unsupported platform"
#endif
}

2
tests/unittests/navigation_unittest.cc
View File

@ -174,7 +174,7 @@ TEST(NavigationTest, History)
new HistoryNavTestHandler();
handler->ExecuteTest();
for (int i = 0; i < NAV_LIST_SIZE(); ++i) {
for (size_t i = 0; i < NAV_LIST_SIZE(); ++i) {
if (kNavList[i].action != NA_CLEAR) {
ASSERT_TRUE(handler->got_before_browse_[i]) << "i = " << i;
ASSERT_TRUE(handler->got_correct_target_[i]) << "i = " << i;

2
tests/unittests/v8_unittest.cc
View File

@ -90,7 +90,7 @@ public:
value = arguments[argct]->GetValue(subargct);
ASSERT_TRUE(value.get() != NULL);
ASSERT_TRUE(value->IsBool());
ASSERT_EQ(false, value->GetBoolValue());
ASSERT_FALSE(value->GetBoolValue());
subargct++;
value = arguments[argct]->GetValue(subargct);

9
tools/build_projects.sh
View File

@ -1,4 +1,4 @@
#!/bin/sh
#!/bin/bash
if [ -z "$1" ]; then
echo "ERROR: Please specify a build target: Debug or Release"
@ -8,6 +8,11 @@ else
else
PROJECT_NAME=$2
fi
if [ `uname` = "Linux" ]; then
pushd ../../
make BUILDTYPE=$1 -j 16
popd
else
xcodebuild -project ../cef.xcodeproj -configuration $1 -target $PROJECT_NAME
fi
fi

2
tools/make_capi_header.py
View File

@ -122,7 +122,7 @@ typedef struct _cef_base_t
// Check that the structure |s|, which is defined with a cef_base_t member named
// |base|, is large enough to contain the specified member |f|.
#define CEF_MEMBER_EXISTS(s, f) \\
((int)&((s)->f) - (int)(s) + sizeof((s)->f) <= (s)->base.size)
((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= (s)->base.size)
#define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f))

31
tools/make_distrib.py
View File

@ -140,7 +140,7 @@ if sys.platform == 'win32':
platform = 'windows'
elif sys.platform == 'darwin':
platform = 'macosx'
elif sys.platform == 'linux2':
elif sys.platform.startswith('linux'):
platform = 'linux'
# output directory
@ -149,8 +149,8 @@ output_dir = os.path.abspath(os.path.join(options.outputdir, \
remove_dir(output_dir, options.quiet)
make_dir(output_dir, options.quiet)
# transfer the LICENSE.TXT file
copy_file(os.path.join(cef_dir, 'LICENSE.TXT'), output_dir, options.quiet)
# transfer the LICENSE.txt file
copy_file(os.path.join(cef_dir, 'LICENSE.txt'), output_dir, options.quiet)
# read the variables list from cef_paths.gypi
cef_paths = eval_file(os.path.join(cef_dir, 'cef_paths.gypi'))
@ -314,6 +314,31 @@ elif platform == 'macosx':
write_file(src_file, data)
elif platform == 'linux':
linux_build_dir = os.path.join(cef_dir, os.pardir, 'out')
# transfer build/Debug files
if not options.allowpartial or path_exists(os.path.join(linux_build_dir, 'Debug')):
dst_dir = os.path.join(output_dir, 'Debug')
make_dir(dst_dir, options.quiet)
copy_files(os.path.join(linux_build_dir, 'Debug/lib.target/*'), dst_dir, options.quiet)
copy_file(os.path.join(linux_build_dir, 'Debug/cefclient'), dst_dir, options.quiet)
copy_file(os.path.join(linux_build_dir, 'Debug/chrome.pak'), dst_dir, options.quiet)
copy_dir(os.path.join(linux_build_dir, 'Debug/locales'), os.path.join(dst_dir, 'locales'), options.quiet)
else:
sys.stderr.write("No Debug build files.\n")
# transfer build/Release files
if not options.allowpartial or path_exists(os.path.join(linux_build_dir, 'Release')):
dst_dir = os.path.join(output_dir, 'Release')
make_dir(dst_dir, options.quiet)
copy_files(os.path.join(linux_build_dir, 'Release/lib.target/*'), dst_dir, options.quiet)
copy_file(os.path.join(linux_build_dir, 'Release/cefclient'), dst_dir, options.quiet)
copy_file(os.path.join(linux_build_dir, 'Release/chrome.pak'), dst_dir, options.quiet)
copy_dir(os.path.join(linux_build_dir, 'Release/locales'), os.path.join(dst_dir, 'locales'), options.quiet)
else:
sys.stderr.write("No Release build files.\n")
# transfer include files
transfer_gypi_files(cef_dir, cef_paths['includes_linux'], \
'include/', include_dir, options.quiet)