Moving sources to src part 1: Move files.

This only move files without adjusting any paths.

This moves:
- lib/quick -> src/webengine/api (API files)
  lib/quick -> src/webengine (other files)
  This contains the main QtWebEngine module library since
  <ec7b2ee70a8b2db7fb87f50671a001ddd54697b0>.
- lib/widgets -> src/webenginewidgets
  Also rename this directory to match its module name and rename Api to api.
- lib -> src/core
- process -> src/process
- resources -> src/core/resources
- tools/* -> tools/scripts/

The build directory is spread as follow:
- build/build.pro -> src/core/gyp_run.pro
- build/qmake_extras/* -> src/core/ (for the host and target .pro files)
- build/qmake -> tools/qmake
- Build related scripts -> tools/buildscripts

Change-Id: I0cded1de772c99c0c1da6536c9afea353236b4a1
Reviewed-by: Zeno Albisser <zeno.albisser@digia.com>
Reviewed-by: Pierre Rossi <pierre.rossi@gmail.com>
Reviewed-by: Andras Becsi <andras.becsi@digia.com>

1 files changed, 167 insertions, 0 deletions

diff --git a/tools/buildscripts/gyp_qtwebengine b/tools/buildscripts/gyp_qtwebengine
new file mode 100755
index 000000000..e715cb821
--- /dev/null
+++ b/tools/buildscripts/gyp_qtwebengine
@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+
+import glob
+import os
+import subprocess
+import sys
+
+print 'using python: ' + sys.executable + ' version: ' + sys.version
+
+qtwebengine_src = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+chrome_src = subprocess.check_output("git config qtwebengine.chromiumsrcdir || true", shell=True).strip()
+if chrome_src:
+  chrome_src = os.path.join(qtwebengine_src, chrome_src)
+if not chrome_src or not os.path.isdir(chrome_src):
+  chrome_src = os.path.join(qtwebengine_src, '3rdparty/chromium')
+  print 'CHROMIUM_SRC_DIR not set, falling back to ' + chrome_src
+
+script_dir = os.path.abspath(os.path.join(chrome_src, 'build'))
+if not os.path.isdir(script_dir):
+  print script_dir + " is not a valid directory"
+  sys.exit(1)
+root_dir = os.path.abspath(os.path.join(os.getcwd(), os.pardir))
+
+sys.path.insert(0, script_dir)
+import gyp_helper
+sys.path.insert(0, os.path.join(chrome_src, 'tools', 'gyp', 'pylib'))
+import gyp
+
+# Add paths so that pymod_do_main(...) can import files.
+sys.path.insert(1, os.path.join(chrome_src, 'tools', 'grit'))
+sys.path.insert(1, os.path.join(chrome_src, 'tools', 'generate_shim_headers'))
+
+sys.path.insert(1, os.path.join(chrome_src, 'third_party', 'WebKit',
+    'Source', 'core', 'core.gyp', 'scripts'))
+# Remove the above and keep the line below once we require a newer specific
+# Chromium revision.
+sys.path.insert(1, os.path.join(chrome_src, 'third_party', 'WebKit',
+    'Source', 'core', 'scripts'))
+
+sys.path.insert(1, os.path.join(chrome_src, 'chrome', 'tools', 'build'))
+
+import repack_locales
+
+def additional_include_files(args=[]):
+  """
+  Returns a list of additional (.gypi) files to include, without
+  duplicating ones that are already specified on the command line.
+  """
+  # Determine the include files specified on the command line.
+  # This doesn't cover all the different option formats you can use,
+  # but it's mainly intended to avoid duplicating flags on the automatic
+  # makefile regeneration which only uses this format.
+  specified_includes = set()
+  for arg in args:
+    if arg.startswith('-I') and len(arg) > 2:
+      specified_includes.add(os.path.realpath(arg[2:]))
+
+  result = []
+  def AddInclude(path):
+    if os.path.realpath(path) not in specified_includes:
+      result.append(path)
+
+  # Always include common.gypi.
+  AddInclude(os.path.join(script_dir, 'common.gypi'))
+
+  # Used for additional build tweaks such as file exclusions
+  AddInclude(os.path.join(qtwebengine_src, 'build', 'qtwebengine_extras.gypi'))
+
+  # Common stuff we generate and extract from qmake
+  AddInclude(os.path.join(qtwebengine_src, 'build', 'qmake_extras.gypi'))
+
+  # Optionally add supplemental .gypi files if present.
+  supplements = glob.glob(os.path.join(chrome_src, '*', 'supplement.gypi'))
+  for supplement in supplements:
+    AddInclude(supplement)
+
+  return result
+
+# TODO: later we probably want to hook that up with qmake to allow shadow builds. (Might not play nice with the rest of chromium though)
+def get_output_dir():
+  outdir = os.path.join(root_dir, "out") # Hardcode for now
+  if not os.path.isdir(outdir):
+    os.mkdir(outdir)
+
+  return outdir
+
+if __name__ == '__main__':
+  args = sys.argv[1:]
+
+  # On Mac we want to override CXX and CC that is provided with
+  # the Chromium GYP environment.
+  if sys.platform.startswith('darwin') and not 'GYP_CROSSCOMPILE' in os.environ:
+    os.environ['CXX'] = 'clang++'
+    os.environ['CC'] = 'clang'
+
+  gyp_helper.apply_chromium_gyp_env()
+
+  # This could give false positives since it doesn't actually do real option
+  # parsing.  Oh well.
+  gyp_file_specified = False
+  for arg in args:
+    if arg.endswith('.gyp'):
+      gyp_file_specified = True
+      break
+
+  if not gyp_file_specified:
+      args.append(os.path.join(root_dir, 'qtwebengine.gyp'))
+
+  args.extend(['-I' + i for i in additional_include_files(args)])
+
+  # On Mac we want to build in x64 mode. And we want to use libc++.
+  # Even though we are not on linux, it seems we specifically have to disable linux_use_tcmalloc.
+  if sys.platform in ('darwin',) and not 'GYP_CROSSCOMPILE' in os.environ:
+      args.extend(['-D', 'host_arch=x64', '-D', 'use_libcpp=1', '-D', 'linux_use_tcmalloc=0'])
+
+  # There shouldn't be a circular dependency relationship between .gyp files,
+  # but in Chromium's .gyp files, on non-Mac platforms, circular relationships
+  # currently exist.  The check for circular dependencies is currently
+  # bypassed on other platforms, but is left enabled on the Mac, where a
+  # violation of the rule causes Xcode to misbehave badly.
+  # TODO(mark): Find and kill remaining circular dependencies, and remove this
+  # option.  http://crbug.com/35878.
+  # TODO(tc): Fix circular dependencies in ChromiumOS then add linux2 to the
+  # list.
+  if sys.platform not in ('darwin',):
+    args.append('--no-circular-check')
+
+  args.extend(['-D', 'webkit_src_dir=' + chrome_src + '/third_party/WebKit'])
+  # the top_level source directory is the first common ancestor of our module and the chromium source tree for the build to be sane.
+  # commonprefix works on a character basis, so it might return a phony common prefix (not the common parent directory we expect),
+  toplevel= os.path.commonprefix([root_dir, chrome_src])
+  if not os.path.exists(toplevel):
+    toplevel = os.path.join(toplevel, os.pardir)
+  args.extend(["--toplevel-dir=" + toplevel])
+  # Chromium specific Hack: for Chromium to build, the depth has to be set to the chromium src dir.
+  args.extend(["--depth=" + chrome_src])
+  args.extend(['-D', 'qtwebengine_src_dir=' + qtwebengine_src])
+  args.extend(['-D', 'chromium_src_dir=' + chrome_src])
+
+  if 'qt_cross_compile=1' in sys.argv:
+    os.environ['GYP_CROSSCOMPILE'] = '1'
+
+  # linux_use_gold_binary currently relies on a hardcoded relative path from chromium/src/out/(Release|Debug)
+  # Disable it along with the -Wl,--threads flag just in case gold isn't installed on the system.
+  args.extend(['-D', 'linux_use_gold_binary=0'])
+  args.extend(['-D', 'linux_use_gold_flags=0'])
+  # Trigger Qt-specific build conditions.
+  args.extend(['-D', 'use_qt=1'])
+  # Tweak the output location and format (hardcode ninja for now if not set)
+  args.extend(['--generator-output', os.path.abspath(get_output_dir())])
+  args.extend(['-Goutput_dir='+ os.path.abspath(get_output_dir())])
+  if not os.environ.get('GYP_GENERATORS'):
+    args.extend(['--format=ninja'])
+  if "QTWEBENGINE_GYP_DEBUG" in os.environ:
+    args.append("--check")
+    args.append("-d all")
+    print args
+    ret_code = gyp.main(args)
+    sys.exit(ret_code)
+
+  ###################################
+
+  print 'Updating projects from gyp files...'
+  #sys.stdout.flush()
+
+  # Off we go...
+  sys.exit(gyp.main(args))