Fix Mac error: icudtl.dat not found in bundle (cztomczak#304)...

cztomczak · cztomczak · commit da6bbeda1c26 · 2017-02-28T17:43:55.000+01:00
hello_world.py example runs fine on Mac!

Add "Location of CEF framework in Mac apps" to Knowledge Base.

Set ApplicationSettings.framework_dir_path when not set
during a call to cef.Initialize(). Also set resources_dir_path.

Fix rpath to "@loader_path/" so that libraries load correctly.

Other fixes in build tools and in docs.
diff --git a/api/API-index.md b/api/API-index.md
@@ -12,6 +12,7 @@
   * [context_menu](ApplicationSettings.md#context_menu)
   * [downloads_enabled](ApplicationSettings.md#downloads_enabled)
   * [external_message_pump](ApplicationSettings.md#external_message_pump)
+  * [framework_dir_path](ApplicationSettings.md#framework_dir_path)
   * [ignore_certificate_errors](ApplicationSettings.md#ignore_certificate_errors)
   * [javascript_flags](ApplicationSettings.md#javascript_flags)
   * [locale](ApplicationSettings.md#locale)
@@ -113,7 +114,6 @@
   * [accept_language_list](BrowserSettings.md#accept_language_list)
   * [application_cache_disabled](BrowserSettings.md#application_cache_disabled)
   * [background_color](BrowserSettings.md#background_color)
-  * [caret_browsing_enabled](BrowserSettings.md#caret_browsing_enabled)
   * [databases_disabled](BrowserSettings.md#databases_disabled)
   * [default_encoding](BrowserSettings.md#default_encoding)
   * [dom_paste_disabled](BrowserSettings.md#dom_paste_disabled)
diff --git a/api/ApplicationSettings.md b/api/ApplicationSettings.md
@@ -189,7 +189,7 @@ then the framework must exist at "Contents/Frameworks/Chromium Embedded
 Framework.framework" in the top-level app bundle. Also configurable using
 the "framework-dir-path" command-line switch.
 
-See also Issue #304.
+See also [Issue #304](../../../issues/304).
 
 
 ### ignore_certificate_errors
diff --git a/docs/Knowledge-Base.md b/docs/Knowledge-Base.md
@@ -50,6 +50,48 @@ they are all unicode strings. Be aware of this when porting cefpython
 based apps to Python 3, as it may cause issues.
 
 
+## Location of CEF framework in Mac apps
+
+This information here is for when creating apps for distribution
+on Mac.
+
+By default CEF expects that CEF framework is located at
+`Contents/Frameworks/Chromium Embedded Framework.framework`
+in the top-level app bundle. If that is not the case then you have
+to set ApplicationSettings.[framework_dir_path]
+(../api/ApplicationSettings.md#framework_dir_path) before calling
+cef.Initialize().
+
+You may also need to change the structure and embedded paths in
+CEF framework and in the cefpython module. Here are the default
+settings:
+```
+cefpython_package/
+    cefpython_py27.so
+        rpath=@loader_path
+        load:@rpath/Chromium Embedded Framework.framework/Chromium Embedded Framework
+    Chromium Embedded Framework.framework/
+        Chromium Embedded Framework
+            id:@rpath/Chromium Embedded Framework.framework/Chromium Embedded Framework
+```
+
+When creating Mac app for distribution you may want to change
+directory structure, so you might have to change these settings
+embedded in these libraries. You can do so with these commands:
+
+```
+install_name_tool -rpath old new
+install_name_tool -change old new
+install_name_tool -id name
+```
+
+To check whether it succeeded run these commands:
+```
+otool -l file
+otool -L file
+```
+
+
 ## Flash support
 
 See [Issue #235](../../../issues/235) ("Flash support in CEF 51+").
diff --git a/src/cefpython.pyx b/src/cefpython.pyx
@@ -577,12 +577,18 @@ cdef public int CommandLineSwitches_GetInt(const char* key) except * with gil:
 # is called. See Issue #73 in the CEF Python Issue Tracker.
 
 def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs):
+    # applicationSettings and commandLineSwitches argument
+    # names are kept for backward compatibility.
+    application_settings = applicationSettings
+    command_line_switches = commandLineSwitches
 
     # Alternative names for existing parameters
     if "settings" in kwargs:
-        applicationSettings = kwargs["settings"]
+        assert not applicationSettings, "Bad arguments"
+        application_settings = kwargs["settings"]
     if "switches" in kwargs:
-        commandLineSwitches = kwargs["switches"]
+        assert not command_line_switches, "Bad arguments"
+        command_line_switches = kwargs["switches"]
 
     IF UNAME_SYSNAME == "Linux":
         # Fix Issue #231 - Discovery of the "icudtl.dat" file fails on Linux.
@@ -595,16 +601,17 @@ def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs):
                 or Debug("ERROR: CefOverridePath failed")
     # END IF UNAME_SYSNAME == "Linux":
 
-    if not applicationSettings:
-        applicationSettings = {}
+    if not application_settings:
+        application_settings = {}
+
     # Debug settings need to be set before Debug() is called
     # and before the CefPythonApp class is instantiated.
     global g_debug
     global g_debugFile
-    if "debug" in applicationSettings:
-        g_debug = bool(applicationSettings["debug"])
-    if "log_file" in applicationSettings:
-        g_debugFile = applicationSettings["log_file"]
+    if "debug" in application_settings:
+        g_debug = bool(application_settings["debug"])
+    if "log_file" in application_settings:
+        g_debugFile = application_settings["log_file"]
 
     Debug("Initialize() called")
 
@@ -617,65 +624,79 @@ def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs):
     # -------------------------------------------------------------------------
     # CEF Python only options - default values
 
-    if "debug" not in applicationSettings:
-        applicationSettings["debug"] = False
-    if "log_severity" not in applicationSettings:
+    if "debug" not in application_settings:
+        application_settings["debug"] = False
+    if "log_severity" not in application_settings:
         # By default show only errors. Don't show on Linux X server non-fatal
         # errors like "WARNING:x11_util.cc(1409)] X error received".
-        applicationSettings["log_severity"] = LOGSEVERITY_ERROR
-    if "string_encoding" not in applicationSettings:
-        applicationSettings["string_encoding"] = "utf-8"
-    if "unique_request_context_per_browser" not in applicationSettings:
-        applicationSettings["unique_request_context_per_browser"] = False
-    if "downloads_enabled" not in applicationSettings:
-        applicationSettings["downloads_enabled"] = True
-    if "remote_debugging_port" not in applicationSettings:
-        applicationSettings["remote_debugging_port"] = 0
-    if "auto_zooming" not in applicationSettings:
+        application_settings["log_severity"] = LOGSEVERITY_ERROR
+    if "string_encoding" not in application_settings:
+        application_settings["string_encoding"] = "utf-8"
+    if "unique_request_context_per_browser" not in application_settings:
+        application_settings["unique_request_context_per_browser"] = False
+    if "downloads_enabled" not in application_settings:
+        application_settings["downloads_enabled"] = True
+    if "remote_debugging_port" not in application_settings:
+        application_settings["remote_debugging_port"] = 0
+    if "auto_zooming" not in application_settings:
         IF UNAME_SYSNAME == "Windows":
             if DpiAware.IsProcessDpiAware():
-                applicationSettings["auto_zooming"] = "system_dpi"
+                application_settings["auto_zooming"] = "system_dpi"
 
     # Paths
     cdef str module_dir = GetModuleDirectory()
-    if "locales_dir_path" not in applicationSettings:
+    if platform.system() == "Darwin":
+        if  "framework_dir_path" not in application_settings:
+            application_settings["framework_dir_path"] = os.path.join(
+                    module_dir, "Chromium Embedded Framework.framework")
+            # Bug in CEF: CefSettings.framework_dir_path doesn't work.
+            #             Can be worked around by setting command line switch.
+            if not command_line_switches:
+                command_line_switches = {}
+            if "framework-dir-path" not in command_line_switches:
+                command_line_switches["framework-dir-path"] = \
+                        application_settings["framework_dir_path"]
+    if "locales_dir_path" not in application_settings:
         if platform.system() != "Darwin":
-            applicationSettings["locales_dir_path"] = os.path.join(
+            application_settings["locales_dir_path"] = os.path.join(
                     module_dir, "locales")
-    if "resources_dir_path" not in applicationSettings:
-        applicationSettings["resources_dir_path"] = module_dir
+    if "resources_dir_path" not in application_settings:
+        application_settings["resources_dir_path"] = module_dir
         if platform.system() == "Darwin":
-            pass  # TODO: Check if this needs to be set in v56+
-    if "browser_subprocess_path" not in applicationSettings:
-        applicationSettings["browser_subprocess_path"] = os.path.join(
+            # "framework_dir_path" will always be set, see code above.
+            application_settings["resources_dir_path"] = os.path.join(
+                    application_settings["framework_dir_path"],
+                    "Resources")
+    if "browser_subprocess_path" not in application_settings:
+        application_settings["browser_subprocess_path"] = os.path.join(
                 module_dir, "subprocess")
 
     # Mouse context menu
-    if "context_menu" not in applicationSettings:
-        applicationSettings["context_menu"] = {}
+    if "context_menu" not in application_settings:
+        application_settings["context_menu"] = {}
     menuItems = ["enabled", "navigation", "print", "view_source",
             "external_browser", "devtools"]
     for item in menuItems:
-        if item not in applicationSettings["context_menu"]:
-            applicationSettings["context_menu"][item] = True
+        if item not in application_settings["context_menu"]:
+            application_settings["context_menu"][item] = True
 
     # Remote debugging port. If value is 0 we will generate a random
     # port. To disable remote debugging set value to -1.
-    if applicationSettings["remote_debugging_port"] == 0:
+    if application_settings["remote_debugging_port"] == 0:
         # Generate a random port.
-        applicationSettings["remote_debugging_port"] =\
+        application_settings["remote_debugging_port"] =\
                 random.randint(49152, 65535)
-    elif applicationSettings["remote_debugging_port"] == -1:
+    elif application_settings["remote_debugging_port"] == -1:
         # Disable remote debugging
-        applicationSettings["remote_debugging_port"] = 0
+        application_settings["remote_debugging_port"] = 0
 
     # -------------------------------------------------------------------------
 
     # CEF options - default values.
-    if not "multi_threaded_message_loop" in applicationSettings:
-        applicationSettings["multi_threaded_message_loop"] = False
-    if not "single_process" in applicationSettings:
-        applicationSettings["single_process"] = False
+    if not "multi_threaded_message_loop" in application_settings:
+        application_settings["multi_threaded_message_loop"] = False
+    if not "single_process" in application_settings:
+        application_settings["single_process"] = False
 
     cdef CefRefPtr[CefApp] cefApp = <CefRefPtr[CefApp]?>new CefPythonApp()
 
@@ -698,21 +719,21 @@ def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs):
     # Make a copy as applicationSettings is a reference only
     # that might get destroyed later.
     global g_applicationSettings
-    for key in applicationSettings:
-        g_applicationSettings[key] = copy.deepcopy(applicationSettings[key])
+    for key in application_settings:
+        g_applicationSettings[key] = copy.deepcopy(application_settings[key])
 
     cdef CefSettings cefApplicationSettings
     # No sandboxing for the subprocesses
     cefApplicationSettings.no_sandbox = 1
-    SetApplicationSettings(applicationSettings, &cefApplicationSettings)
+    SetApplicationSettings(application_settings, &cefApplicationSettings)
 
-    if commandLineSwitches:
+    if command_line_switches:
         # Make a copy as commandLineSwitches is a reference only
         # that might get destroyed later.
         global g_commandLineSwitches
-        for key in commandLineSwitches:
+        for key in command_line_switches:
             g_commandLineSwitches[key] = copy.deepcopy(
-                    commandLineSwitches[key])
+                    command_line_switches[key])
 
     # External message pump
     if GetAppSetting("external_message_pump")\
diff --git a/src/subprocess/Makefile b/src/subprocess/Makefile
@@ -55,4 +55,4 @@ subprocess:
 		$(CPP_FILES) \
 		$(CEF_LINK_FLAGS) \
 		$(LIBS) -lcef_dll_wrapper \
-		-o subprocess -Wl,-rpath,.
+		-o subprocess -Wl,-rpath,@loader_path/
diff --git a/tools/build.py b/tools/build.py
@@ -17,12 +17,13 @@
 from sources or use ready binaries from Spotify Automated Builds.
 
 Usage:
-    build.py VERSION [--rebuild-cpp] [--fast] [--kivy]
+    build.py VERSION [--rebuild-cpp] [--fast] [--clean] [--kivy]
 
 Options:
     VERSION        Version in format xx.xx
     --rebuild-cpp  Force rebuild of C++ projects
     --fast         Fast mode
+    --clean        Clean C++ projects build files (.o .a etc)
     --kivy         Run only Kivy example
 """
 
@@ -221,7 +222,8 @@ def check_cython_version():
 
 
 def command_line_args():
-    global DEBUG_FLAG, FAST_FLAG, KIVY_FLAG, REBUILD_CPP, VERSION
+    global DEBUG_FLAG, FAST_FLAG, CLEAN_FLAG, KIVY_FLAG,\
+           REBUILD_CPP, VERSION
 
     print("[build.py] Parse command line arguments")
 
@@ -393,7 +395,7 @@ def compile_cpp_projects_unix():
     print("[build.py] Compile C++ projects")
     if CLEAN_FLAG:
         print("[build.py] Clean C++ projects (--clean flag passed)")
-    clean_cpp_projects_unix()
+        clean_cpp_projects_unix()
 
     # Need to allow continuing even when make fails, as it may
     # fail because the "public" function declaration is not yet
@@ -686,6 +688,7 @@ def delete_files_by_pattern(pattern):
     files = glob.glob(pattern)
     for f in files:
         os.remove(f)
+    print("[build.py] Removed {0} files".format(len(files)))
 
 
 def delete_directories_by_pattern(pattern):
diff --git a/tools/build_module.py b/tools/build_module.py
@@ -229,7 +229,7 @@ def set_compiler_options(options):
                 "-Wl,-search_paths_first",
                 "-F"+os.path.join(CEF_BINARIES_LIBRARIES, "bin"),
                 "-framework", "Chromium Embedded Framework",
-                "-Wl,-rpath,@loader_path",
+                "-Wl,-rpath,@loader_path/",  # ending slash is crucial!
         ])
         if not FAST_FLAG:
             extra_link_args.extend([
