sqlite: Move //third_party/sqlite/src/ to //third_party/sqlite/patched/.

Currently, the original SQLite code is stored at
//third_party/sqlite/sqlite-src-* and Chrome's patched code is stored at
//third_party/sqlite/src/. This CL moves the patched code to a patched/
directory, as the new name better reflects what's going on.

This CL also paves the way for a future where the original SQLite code
is brought into //third_party/sqlite/src/ via DEPS.

Bug: 945204
Change-Id: I004906acde8f64ce5006c9bfa1902e6aa3c5227c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1537161
Commit-Queue: Victor Costan <pwnall@chromium.org>
Reviewed-by: Chris Mumford <cmumford@google.com>
Cr-Commit-Position: refs/heads/master@{#643946}

sql/recovery.cc

@@ -16,7 +16,9 @@
 #include "sql/database.h"
 #include "sql/statement.h"
 #include "third_party/sqlite/sqlite3.h"
-#include "third_party/sqlite/src/src/recover.h"
+
+// Needs to be included after "third_party/sqlite/sqlite.h".
+#include "third_party/sqlite/patched/src/recover.h"
 
 namespace sql {
 

third_party/sqlite/BUILD.gn

@@ -80,8 +80,8 @@ config("chromium_sqlite3_compile_options") {
     # syntax, for instance SQLITE_OMIT_VIRTUALTABLE omits the virtual table
     # syntax entirely. Missing an item usually results in syntax working but
     # execution failing. Review:
-    #   src/src/parse.py
-    #   src/tool/mkkeywordhash.c
+    #   patched/src/parse.py
+    #   patched/tool/mkkeywordhash.c
 
     # The flags below are recommended in the SQLite documentation, and disable
     # features Chrome doesn't use.
@@ -270,7 +270,7 @@ config("sqlite_warnings") {
     ]
   }
   if (is_win && !is_clang) {
-    cflags += [ "/wd4101" ]  # 'zTrace' unreferenced variable in src/vdbe.c
+    cflags += [ "/wd4101" ]  # 'zTrace' unreferenced variable in patched/vdbe.c
   }
 }
 
@@ -279,15 +279,15 @@ component("chromium_sqlite3") {
   visibility = [ ":*" ]
 
   public = [
+    "patched/src/recover.h",
     "sqlite3.h",
-    "src/src/recover.h",
   ]
 
   sources = [
     "amalgamation/sqlite3.h",
+    "patched/src/recover.c",
+    "patched/src/recover_varint.c",
     "sqlite3_shim.c",
-    "src/src/recover.c",
-    "src/src/recover_varint.c",
   ]
 
   inputs = [
@@ -394,11 +394,11 @@ if (is_win || is_mac || is_linux) {
     ]
 
     if (is_linux) {
-      sources += [ "src/src/shell_icu_linux.c" ]
+      sources += [ "patched/src/shell_icu_linux.c" ]
     }
 
     if (is_win) {
-      sources += [ "src/src/shell_icu_win.c" ]
+      sources += [ "patched/src/shell_icu_win.c" ]
     }
 
     deps = [
@@ -422,7 +422,7 @@ if (is_win || is_mac || is_linux) {
 fuzzer_test("sqlite3_ossfuzz_fuzzer") {
   include_dirs = [ "." ]
   sources = [
-    "src/test/ossfuzz.c",
+    "patched/test/ossfuzz.c",
   ]
   deps = [
     ":sqlite",
@@ -582,7 +582,7 @@ if (use_fuzzing_engine) {
   fuzzer_test("sqlite3_dbfuzz2_fuzzer") {
     include_dirs = [ "." ]
     sources = [
-      "src/test/dbfuzz2.c",
+      "patched/test/dbfuzz2.c",
     ]
     deps = [
       ":sqlite",

third_party/sqlite/README.chromium

@@ -37,7 +37,7 @@ The directory structure is as follows. Files common to all third_party projects
 * patches/ - Our patches to the currently used release, formatted by git using
              the UNIX mailbox format. The patches can be applied with git am,
              and created with git format-patch.
-* src/ - The currently used source code, with our patches applied.
+* patched/ - The currently used source code, with our patches applied.
 * amalgamation/ - The supported method of using SQLite is via an amalgamation
                   build, which merges all the code in one .c file and one .h
                   file. See https://www.sqlite.org/amalgamation.html
@@ -51,20 +51,20 @@ The directory structure is as follows. Files common to all third_party projects
 
 2) Making changes to Chromium SQLite.
 
-third_party/sqlite/src is the patched source from SQLite.  This is used to
+third_party/sqlite/patched is the patched source from SQLite.  This is used to
 generate the amalgamation, a concatenation of all of the files into a giant
-sqlite3.c.  To prototype, edit in src/, then call
+sqlite3.c.  To prototype, edit in patched/, then call
   ./scripts/generate_amalgamation.sh
-to regenerate sqlite3.c.  The code in src/ is much easier to edit, and the
+to regenerate sqlite3.c.  The code in patched/ is much easier to edit, and the
 SQLite test framework can easily be run.  During development it may be
-convenient to modify BUILD.gn based on src/main.mk to just pull in the src/
-files rather than sqlite3.c.
+convenient to modify BUILD.gn based on patched/main.mk to just pull in the
+patched/ files rather than sqlite3.c.
 
 Once your patch is complete, squash it down into a reasonable CL, then
 re-generate the patches.  This is a truncated version of the import flow.  The
 following is written like a shell script to allow copy/paste to a shell, ignore
 comments and change the obvious lines.  These instructions should work on Linux
-or OSX.  They may assume a modern version of git (I'm using 2.2.1).
+or OSX.  They may assume a modern version of git.
 
 # The steps below are easier if done in the SQLite directory.
 cd third_party/sqlite
@@ -76,22 +76,22 @@ export GNU_SED=sed  # OSX: "brew install gnu-sed", then use "gsed" here.
 
 #### Create a reference branch.
 git new-branch sqlite-base
-git rm -rf src
-cp -r sqlite-src-${BASE}/ src
+git rm -rf patched
+cp -r sqlite-src-${BASE}/ patched
 # Clean up trailing whitespace and CRLF so any patches look clean.
-find src/ -type f -not -iname "*.db" -not -iname "*.eps" -not -iname "*.ico" \
-    -not -iname "*.jpg" -not -iname "*.pfx" -not -iname "*.png" \
-    -not -iname "*.tiff" -not -iname "*.vsix" \
+find patched/ -type f -not -iname "*.db" -not -iname "*.eps" \
+    -not -iname "*.ico" -not -iname "*.jpg" -not -iname "*.pfx" \
+    -not -iname "*.png" -not -iname "*.tiff" -not -iname "*.vsix" \
     -exec ${GNU_SED} --in-place 's/[[:space:]]\+$//' {} \+
-git add src/
-git clean -i -d -x src  # Make sure no file is git-ignored.
-git commit -m "Squash: Reset SQLite src/ to sqlite-src-${BASE}."
+git add patched/
+git clean -i -d -x patched  # Make sure no file is git-ignored.
+git commit -m "Squash: Reset SQLite patched/ to sqlite-src-${BASE}."
 # This branch will not build. It will be used for rebasing, then deleted.
 
 #### Create a reference branch with patches applied.
 git new-branch --upstream-current sqlite-dev
 git am --keep-non-patch --ignore-space-change patches/*.patch
-git diff origin/master src/
+git diff origin/master patched/
 # This branch should be identical to master.
 
 
@@ -185,38 +185,38 @@ git cl upload  # Have the new code in a separate (impossible to review) CL.
 
 #### Create a branch for the old SQLite release's upstream version.
 git new-branch sqlite-old-base
-git rm -rf src
-cp -r sqlite-src-${OLD}/ src
+git rm -rf patached
+cp -r sqlite-src-${OLD}/ patched
 # Clean up trailing whitespace and CRLF so any patches look clean.
-find src/ -type f -not -iname "*.db" -not -iname "*.eps" -not -iname "*.ico" \
-    -not -iname "*.jpg" -not -iname "*.pfx" -not -iname "*.png" \
-    -not -iname "*.tiff" -not -iname "*.vsix" \
+find patched/ -type f -not -iname "*.db" -not -iname "*.eps" \
+    -not -iname "*.ico" -not -iname "*.jpg" -not -iname "*.pfx" \
+    -not -iname "*.png" -not -iname "*.tiff" -not -iname "*.vsix" \
     -exec ${GNU_SED} --in-place 's/[[:space:]]\+$//' {} \+
-git add src/
-git clean -i -d -x src  # Make sure no file is git-ignored.
-git commit -m "Squash: Reset SQLite src/ to sqlite-src-${OLD}."
+git add patched/
+git clean -i -d -x patched  # Make sure no file is git-ignored.
+git commit -m "Squash: Reset SQLite patched/ to sqlite-src-${OLD}."
 # This branch will not build. It will be used for rebasing, then deleted.
 
 #### Create a branch for our old SQLite code, with patches mapped to commits.
 git new-branch --upstream-current sqlite-old
 git am --keep-non-patch --ignore-space-change patches/*.patch
-git diff origin/master src/
+git diff origin/master patched/
 # This branch should be identical to master.
 
 #### Create a branch for the new SQLite release's upstream version.
 git checkout sqlite-old-base
 git new-branch --upstream-current sqlite-new-base
-git rm -rf src
+git rm -rf patched
 git checkout sqlite-new-upstream -- sqlite-src-${NEW}/
-git mv sqlite-src-${NEW}/ src
+git mv sqlite-src-${NEW}/ patched
 # Clean up trailing whitespace and CRLF so any patches look clean.
-find src/ -type f -not -iname "*.db" -not -iname "*.eps" -not -iname "*.ico" \
-    -not -iname "*.jpg" -not -iname "*.pfx" -not -iname "*.png" \
-    -not -iname "*.tiff" -not -iname "*.vsix" \
+find patched/ -type f -not -iname "*.db" -not -iname "*.eps" \
+    -not -iname "*.ico" -not -iname "*.jpg" -not -iname "*.pfx" \
+    -not -iname "*.png" -not -iname "*.tiff" -not -iname "*.vsix" \
     -exec ${GNU_SED} --in-place 's/[[:space:]]\+$//' {} \+
-git add src/
-git clean -i -d -x src  # Make sure no file is git-ignored.
-git commit -m "Squash: Reset SQLite src/ to sqlite-src-${NEW}."
+git add patched/
+git clean -i -d -x patched  # Make sure no file is git-ignored.
+git commit -m "Squash: Reset SQLite patched/ to sqlite-src-${NEW}."
 # This branch will not build. It will be used for rebasing, then deleted.
 
 #### Create a branch for updating our patches.
@@ -235,9 +235,9 @@ git cl format amalgamation/rename_exports.h
 #### Copy any new entries to the seed-corpus for dbfuzz2.
 # We use a set of seed databases for fuzzing SQLite's resilience to database
 # corruption. Sometimes, new seed databases are added upstream.
-# Find any files of the pattern src/test/dbfuzz2-seed*.db, and copy them to
+# Find any files of the pattern patched/test/dbfuzz2-seed*.db, and copy them to
 # the fuzz/db_corpus directory.
-cp --no-clobber src/test/dbfuzz2-seed*.db fuzz/db_corpus
+cp --no-clobber patched/test/dbfuzz2-seed*.db fuzz/db_corpus
 
 #### Validate the upgrade.
 # The goal is to have a set of reasonably-independent CLs which can be