Use Google3 style guide with .clang-format

Test: style change only, builds ok
Change-Id: I885180e24cb2e7b58cfb4967c3bcb40058ce4078

1 files changed, 326 insertions, 337 deletions

diff --git a/tools/aapt2/diff/Diff.cpp b/tools/aapt2/diff/Diff.cpp
index 9b1f0572123d..01f45399511f 100644
--- a/tools/aapt2/diff/Diff.cpp
+++ b/tools/aapt2/diff/Diff.cpp
@@ -27,412 +27,401 @@
 namespace aapt {
 
 class DiffContext : public IAaptContext {
-public:
-    const std::string& getCompilationPackage() override {
-        return mEmpty;
-    }
+ public:
+  const std::string& getCompilationPackage() override { return mEmpty; }
 
-    uint8_t getPackageId() override {
-        return 0x0;
-    }
+  uint8_t getPackageId() override { return 0x0; }
 
-    IDiagnostics* getDiagnostics() override {
-        return &mDiagnostics;
-    }
+  IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
 
-    NameMangler* getNameMangler() override {
-        return &mNameMangler;
-    }
+  NameMangler* getNameMangler() override { return &mNameMangler; }
 
-    SymbolTable* getExternalSymbols() override {
-        return &mSymbolTable;
-    }
+  SymbolTable* getExternalSymbols() override { return &mSymbolTable; }
 
-    bool verbose() override {
-        return false;
-    }
+  bool verbose() override { return false; }
 
-    int getMinSdkVersion() override {
-        return 0;
-    }
+  int getMinSdkVersion() override { return 0; }
 
-private:
-    std::string mEmpty;
-    StdErrDiagnostics mDiagnostics;
-    NameMangler mNameMangler = NameMangler(NameManglerPolicy{});
-    SymbolTable mSymbolTable;
+ private:
+  std::string mEmpty;
+  StdErrDiagnostics mDiagnostics;
+  NameMangler mNameMangler = NameMangler(NameManglerPolicy{});
+  SymbolTable mSymbolTable;
 };
 
 class LoadedApk {
-public:
-    LoadedApk(const Source& source, std::unique_ptr<io::IFileCollection> apk,
-              std::unique_ptr<ResourceTable> table) :
-            mSource(source), mApk(std::move(apk)), mTable(std::move(table)) {
-    }
+ public:
+  LoadedApk(const Source& source, std::unique_ptr<io::IFileCollection> apk,
+            std::unique_ptr<ResourceTable> table)
+      : mSource(source), mApk(std::move(apk)), mTable(std::move(table)) {}
 
-    io::IFileCollection* getFileCollection() {
-        return mApk.get();
-    }
+  io::IFileCollection* getFileCollection() { return mApk.get(); }
 
-    ResourceTable* getResourceTable() {
-        return mTable.get();
-    }
+  ResourceTable* getResourceTable() { return mTable.get(); }
 
-    const Source& getSource() {
-        return mSource;
-    }
+  const Source& getSource() { return mSource; }
 
-private:
-    Source mSource;
-    std::unique_ptr<io::IFileCollection> mApk;
-    std::unique_ptr<ResourceTable> mTable;
+ private:
+  Source mSource;
+  std::unique_ptr<io::IFileCollection> mApk;
+  std::unique_ptr<ResourceTable> mTable;
 
-    DISALLOW_COPY_AND_ASSIGN(LoadedApk);
+  DISALLOW_COPY_AND_ASSIGN(LoadedApk);
 };
 
-static std::unique_ptr<LoadedApk> loadApkFromPath(IAaptContext* context, const StringPiece& path) {
-    Source source(path);
-    std::string error;
-    std::unique_ptr<io::ZipFileCollection> apk = io::ZipFileCollection::create(path, &error);
-    if (!apk) {
-        context->getDiagnostics()->error(DiagMessage(source) << error);
-        return {};
-    }
-
-    io::IFile* file = apk->findFile("resources.arsc");
-    if (!file) {
-        context->getDiagnostics()->error(DiagMessage(source) << "no resources.arsc found");
-        return {};
-    }
-
-    std::unique_ptr<io::IData> data = file->openAsData();
-    if (!data) {
-        context->getDiagnostics()->error(DiagMessage(source) << "could not open resources.arsc");
-        return {};
-    }
-
-    std::unique_ptr<ResourceTable> table = util::make_unique<ResourceTable>();
-    BinaryResourceParser parser(context, table.get(), source, data->data(), data->size());
-    if (!parser.parse()) {
-        return {};
-    }
-
-    return util::make_unique<LoadedApk>(source, std::move(apk), std::move(table));
+static std::unique_ptr<LoadedApk> loadApkFromPath(IAaptContext* context,
+                                                  const StringPiece& path) {
+  Source source(path);
+  std::string error;
+  std::unique_ptr<io::ZipFileCollection> apk =
+      io::ZipFileCollection::create(path, &error);
+  if (!apk) {
+    context->getDiagnostics()->error(DiagMessage(source) << error);
+    return {};
+  }
+
+  io::IFile* file = apk->findFile("resources.arsc");
+  if (!file) {
+    context->getDiagnostics()->error(DiagMessage(source)
+                                     << "no resources.arsc found");
+    return {};
+  }
+
+  std::unique_ptr<io::IData> data = file->openAsData();
+  if (!data) {
+    context->getDiagnostics()->error(DiagMessage(source)
+                                     << "could not open resources.arsc");
+    return {};
+  }
+
+  std::unique_ptr<ResourceTable> table = util::make_unique<ResourceTable>();
+  BinaryResourceParser parser(context, table.get(), source, data->data(),
+                              data->size());
+  if (!parser.parse()) {
+    return {};
+  }
+
+  return util::make_unique<LoadedApk>(source, std::move(apk), std::move(table));
 }
 
 static void emitDiffLine(const Source& source, const StringPiece& message) {
-    std::cerr << source << ": " << message << "\n";
+  std::cerr << source << ": " << message << "\n";
 }
 
-static bool isSymbolVisibilityDifferent(const Symbol& symbolA, const Symbol& symbolB) {
-    return symbolA.state != symbolB.state;
+static bool isSymbolVisibilityDifferent(const Symbol& symbolA,
+                                        const Symbol& symbolB) {
+  return symbolA.state != symbolB.state;
 }
 
 template <typename Id>
 static bool isIdDiff(const Symbol& symbolA, const Maybe<Id>& idA,
                      const Symbol& symbolB, const Maybe<Id>& idB) {
-    if (symbolA.state == SymbolState::kPublic || symbolB.state == SymbolState::kPublic) {
-        return idA != idB;
-    }
-    return false;
+  if (symbolA.state == SymbolState::kPublic ||
+      symbolB.state == SymbolState::kPublic) {
+    return idA != idB;
+  }
+  return false;
 }
 
-static bool emitResourceConfigValueDiff(IAaptContext* context,
-                                        LoadedApk* apkA,
-                                        ResourceTablePackage* pkgA,
-                                        ResourceTableType* typeA,
-                                        ResourceEntry* entryA,
-                                        ResourceConfigValue* configValueA,
-                                        LoadedApk* apkB,
-                                        ResourceTablePackage* pkgB,
-                                        ResourceTableType* typeB,
-                                        ResourceEntry* entryB,
-                                        ResourceConfigValue* configValueB) {
-    Value* valueA = configValueA->value.get();
-    Value* valueB = configValueB->value.get();
-    if (!valueA->equals(valueB)) {
-        std::stringstream strStream;
-        strStream << "value " << pkgA->name << ":" << typeA->type << "/" << entryA->name
-                << " config=" << configValueA->config << " does not match:\n";
-        valueA->print(&strStream);
-        strStream << "\n vs \n";
-        valueB->print(&strStream);
-        emitDiffLine(apkB->getSource(), strStream.str());
-        return true;
-    }
-    return false;
+static bool emitResourceConfigValueDiff(
+    IAaptContext* context, LoadedApk* apkA, ResourceTablePackage* pkgA,
+    ResourceTableType* typeA, ResourceEntry* entryA,
+    ResourceConfigValue* configValueA, LoadedApk* apkB,
+    ResourceTablePackage* pkgB, ResourceTableType* typeB, ResourceEntry* entryB,
+    ResourceConfigValue* configValueB) {
+  Value* valueA = configValueA->value.get();
+  Value* valueB = configValueB->value.get();
+  if (!valueA->equals(valueB)) {
+    std::stringstream strStream;
+    strStream << "value " << pkgA->name << ":" << typeA->type << "/"
+              << entryA->name << " config=" << configValueA->config
+              << " does not match:\n";
+    valueA->print(&strStream);
+    strStream << "\n vs \n";
+    valueB->print(&strStream);
+    emitDiffLine(apkB->getSource(), strStream.str());
+    return true;
+  }
+  return false;
 }
 
-static bool emitResourceEntryDiff(IAaptContext* context,
-                                  LoadedApk* apkA,
+static bool emitResourceEntryDiff(IAaptContext* context, LoadedApk* apkA,
                                   ResourceTablePackage* pkgA,
                                   ResourceTableType* typeA,
-                                  ResourceEntry* entryA,
-                                  LoadedApk* apkB,
+                                  ResourceEntry* entryA, LoadedApk* apkB,
                                   ResourceTablePackage* pkgB,
                                   ResourceTableType* typeB,
                                   ResourceEntry* entryB) {
-    bool diff = false;
-    for (std::unique_ptr<ResourceConfigValue>& configValueA : entryA->values) {
-        ResourceConfigValue* configValueB = entryB->findValue(configValueA->config);
-        if (!configValueB) {
-            std::stringstream strStream;
-            strStream << "missing " << pkgA->name << ":" << typeA->type << "/" << entryA->name
-                    << " config=" << configValueA->config;
-            emitDiffLine(apkB->getSource(), strStream.str());
-            diff = true;
-        } else {
-            diff |= emitResourceConfigValueDiff(context, apkA, pkgA, typeA, entryA,
-                                                configValueA.get(), apkB, pkgB, typeB, entryB,
-                                                configValueB);
-        }
+  bool diff = false;
+  for (std::unique_ptr<ResourceConfigValue>& configValueA : entryA->values) {
+    ResourceConfigValue* configValueB = entryB->findValue(configValueA->config);
+    if (!configValueB) {
+      std::stringstream strStream;
+      strStream << "missing " << pkgA->name << ":" << typeA->type << "/"
+                << entryA->name << " config=" << configValueA->config;
+      emitDiffLine(apkB->getSource(), strStream.str());
+      diff = true;
+    } else {
+      diff |= emitResourceConfigValueDiff(context, apkA, pkgA, typeA, entryA,
+                                          configValueA.get(), apkB, pkgB, typeB,
+                                          entryB, configValueB);
     }
-
-    // Check for any newly added config values.
-    for (std::unique_ptr<ResourceConfigValue>& configValueB : entryB->values) {
-        ResourceConfigValue* configValueA = entryA->findValue(configValueB->config);
-        if (!configValueA) {
-            std::stringstream strStream;
-            strStream << "new config " << pkgB->name << ":" << typeB->type << "/" << entryB->name
-                    << " config=" << configValueB->config;
-            emitDiffLine(apkB->getSource(), strStream.str());
-            diff = true;
-        }
+  }
+
+  // Check for any newly added config values.
+  for (std::unique_ptr<ResourceConfigValue>& configValueB : entryB->values) {
+    ResourceConfigValue* configValueA = entryA->findValue(configValueB->config);
+    if (!configValueA) {
+      std::stringstream strStream;
+      strStream << "new config " << pkgB->name << ":" << typeB->type << "/"
+                << entryB->name << " config=" << configValueB->config;
+      emitDiffLine(apkB->getSource(), strStream.str());
+      diff = true;
     }
-    return false;
+  }
+  return false;
 }
 
-static bool emitResourceTypeDiff(IAaptContext* context,
-                                 LoadedApk* apkA,
+static bool emitResourceTypeDiff(IAaptContext* context, LoadedApk* apkA,
                                  ResourceTablePackage* pkgA,
-                                 ResourceTableType* typeA,
-                                 LoadedApk* apkB,
+                                 ResourceTableType* typeA, LoadedApk* apkB,
                                  ResourceTablePackage* pkgB,
                                  ResourceTableType* typeB) {
-    bool diff = false;
-    for (std::unique_ptr<ResourceEntry>& entryA : typeA->entries) {
-        ResourceEntry* entryB = typeB->findEntry(entryA->name);
-        if (!entryB) {
-            std::stringstream strStream;
-            strStream << "missing " << pkgA->name << ":" << typeA->type << "/" << entryA->name;
-            emitDiffLine(apkB->getSource(), strStream.str());
-            diff = true;
+  bool diff = false;
+  for (std::unique_ptr<ResourceEntry>& entryA : typeA->entries) {
+    ResourceEntry* entryB = typeB->findEntry(entryA->name);
+    if (!entryB) {
+      std::stringstream strStream;
+      strStream << "missing " << pkgA->name << ":" << typeA->type << "/"
+                << entryA->name;
+      emitDiffLine(apkB->getSource(), strStream.str());
+      diff = true;
+    } else {
+      if (isSymbolVisibilityDifferent(entryA->symbolStatus,
+                                      entryB->symbolStatus)) {
+        std::stringstream strStream;
+        strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name
+                  << " has different visibility (";
+        if (entryB->symbolStatus.state == SymbolState::kPublic) {
+          strStream << "PUBLIC";
         } else {
-            if (isSymbolVisibilityDifferent(entryA->symbolStatus, entryB->symbolStatus)) {
-                std::stringstream strStream;
-                strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name
-                        << " has different visibility (";
-                if (entryB->symbolStatus.state == SymbolState::kPublic) {
-                    strStream << "PUBLIC";
-                } else {
-                    strStream << "PRIVATE";
-                }
-                strStream << " vs ";
-                if (entryA->symbolStatus.state == SymbolState::kPublic) {
-                    strStream << "PUBLIC";
-                } else {
-                    strStream << "PRIVATE";
-                }
-                strStream << ")";
-                emitDiffLine(apkB->getSource(), strStream.str());
-                diff = true;
-            } else if (isIdDiff(entryA->symbolStatus, entryA->id,
-                                entryB->symbolStatus, entryB->id)) {
-                std::stringstream strStream;
-                strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name
-                        << " has different public ID (";
-                if (entryB->id) {
-                    strStream << "0x" << std::hex << entryB->id.value();
-                } else {
-                    strStream << "none";
-                }
-                strStream << " vs ";
-                if (entryA->id) {
-                    strStream << "0x " << std::hex << entryA->id.value();
-                } else {
-                    strStream << "none";
-                }
-                strStream << ")";
-                emitDiffLine(apkB->getSource(), strStream.str());
-                diff = true;
-            }
-            diff |= emitResourceEntryDiff(context, apkA, pkgA, typeA, entryA.get(),
-                                          apkB, pkgB, typeB, entryB);
+          strStream << "PRIVATE";
         }
-    }
-
-    // Check for any newly added entries.
-    for (std::unique_ptr<ResourceEntry>& entryB : typeB->entries) {
-        ResourceEntry* entryA = typeA->findEntry(entryB->name);
-        if (!entryA) {
-            std::stringstream strStream;
-            strStream << "new entry " << pkgB->name << ":" << typeB->type << "/" << entryB->name;
-            emitDiffLine(apkB->getSource(), strStream.str());
-            diff = true;
+        strStream << " vs ";
+        if (entryA->symbolStatus.state == SymbolState::kPublic) {
+          strStream << "PUBLIC";
+        } else {
+          strStream << "PRIVATE";
         }
+        strStream << ")";
+        emitDiffLine(apkB->getSource(), strStream.str());
+        diff = true;
+      } else if (isIdDiff(entryA->symbolStatus, entryA->id,
+                          entryB->symbolStatus, entryB->id)) {
+        std::stringstream strStream;
+        strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name
+                  << " has different public ID (";
+        if (entryB->id) {
+          strStream << "0x" << std::hex << entryB->id.value();
+        } else {
+          strStream << "none";
+        }
+        strStream << " vs ";
+        if (entryA->id) {
+          strStream << "0x " << std::hex << entryA->id.value();
+        } else {
+          strStream << "none";
+        }
+        strStream << ")";
+        emitDiffLine(apkB->getSource(), strStream.str());
+        diff = true;
+      }
+      diff |= emitResourceEntryDiff(context, apkA, pkgA, typeA, entryA.get(),
+                                    apkB, pkgB, typeB, entryB);
+    }
+  }
+
+  // Check for any newly added entries.
+  for (std::unique_ptr<ResourceEntry>& entryB : typeB->entries) {
+    ResourceEntry* entryA = typeA->findEntry(entryB->name);
+    if (!entryA) {
+      std::stringstream strStream;
+      strStream << "new entry " << pkgB->name << ":" << typeB->type << "/"
+                << entryB->name;
+      emitDiffLine(apkB->getSource(), strStream.str());
+      diff = true;
     }
-    return diff;
+  }
+  return diff;
 }
 
 static bool emitResourcePackageDiff(IAaptContext* context, LoadedApk* apkA,
-                                    ResourceTablePackage* pkgA,
-                                    LoadedApk* apkB, ResourceTablePackage* pkgB) {
-    bool diff = false;
-    for (std::unique_ptr<ResourceTableType>& typeA : pkgA->types) {
-        ResourceTableType* typeB = pkgB->findType(typeA->type);
-        if (!typeB) {
-            std::stringstream strStream;
-            strStream << "missing " << pkgA->name << ":" << typeA->type;
-            emitDiffLine(apkA->getSource(), strStream.str());
-            diff = true;
+                                    ResourceTablePackage* pkgA, LoadedApk* apkB,
+                                    ResourceTablePackage* pkgB) {
+  bool diff = false;
+  for (std::unique_ptr<ResourceTableType>& typeA : pkgA->types) {
+    ResourceTableType* typeB = pkgB->findType(typeA->type);
+    if (!typeB) {
+      std::stringstream strStream;
+      strStream << "missing " << pkgA->name << ":" << typeA->type;
+      emitDiffLine(apkA->getSource(), strStream.str());
+      diff = true;
+    } else {
+      if (isSymbolVisibilityDifferent(typeA->symbolStatus,
+                                      typeB->symbolStatus)) {
+        std::stringstream strStream;
+        strStream << pkgA->name << ":" << typeA->type
+                  << " has different visibility (";
+        if (typeB->symbolStatus.state == SymbolState::kPublic) {
+          strStream << "PUBLIC";
         } else {
-            if (isSymbolVisibilityDifferent(typeA->symbolStatus, typeB->symbolStatus)) {
-                std::stringstream strStream;
-                strStream << pkgA->name << ":" << typeA->type << " has different visibility (";
-                if (typeB->symbolStatus.state == SymbolState::kPublic) {
-                    strStream << "PUBLIC";
-                } else {
-                    strStream << "PRIVATE";
-                }
-                strStream << " vs ";
-                if (typeA->symbolStatus.state == SymbolState::kPublic) {
-                    strStream << "PUBLIC";
-                } else {
-                    strStream << "PRIVATE";
-                }
-                strStream << ")";
-                emitDiffLine(apkB->getSource(), strStream.str());
-                diff = true;
-            } else if (isIdDiff(typeA->symbolStatus, typeA->id, typeB->symbolStatus, typeB->id)) {
-                std::stringstream strStream;
-                strStream << pkgA->name << ":" << typeA->type << " has different public ID (";
-                if (typeB->id) {
-                    strStream << "0x" << std::hex << typeB->id.value();
-                } else {
-                    strStream << "none";
-                }
-                strStream << " vs ";
-                if (typeA->id) {
-                    strStream << "0x " << std::hex << typeA->id.value();
-                } else {
-                    strStream << "none";
-                }
-                strStream << ")";
-                emitDiffLine(apkB->getSource(), strStream.str());
-                diff = true;
-            }
-            diff |= emitResourceTypeDiff(context, apkA, pkgA, typeA.get(), apkB, pkgB, typeB);
+          strStream << "PRIVATE";
         }
-    }
-
-    // Check for any newly added types.
-    for (std::unique_ptr<ResourceTableType>& typeB : pkgB->types) {
-        ResourceTableType* typeA = pkgA->findType(typeB->type);
-        if (!typeA) {
-            std::stringstream strStream;
-            strStream << "new type " << pkgB->name << ":" << typeB->type;
-            emitDiffLine(apkB->getSource(), strStream.str());
-            diff = true;
+        strStream << " vs ";
+        if (typeA->symbolStatus.state == SymbolState::kPublic) {
+          strStream << "PUBLIC";
+        } else {
+          strStream << "PRIVATE";
         }
+        strStream << ")";
+        emitDiffLine(apkB->getSource(), strStream.str());
+        diff = true;
+      } else if (isIdDiff(typeA->symbolStatus, typeA->id, typeB->symbolStatus,
+                          typeB->id)) {
+        std::stringstream strStream;
+        strStream << pkgA->name << ":" << typeA->type
+                  << " has different public ID (";
+        if (typeB->id) {
+          strStream << "0x" << std::hex << typeB->id.value();
+        } else {
+          strStream << "none";
+        }
+        strStream << " vs ";
+        if (typeA->id) {
+          strStream << "0x " << std::hex << typeA->id.value();
+        } else {
+          strStream << "none";
+        }
+        strStream << ")";
+        emitDiffLine(apkB->getSource(), strStream.str());
+        diff = true;
+      }
+      diff |= emitResourceTypeDiff(context, apkA, pkgA, typeA.get(), apkB, pkgB,
+                                   typeB);
+    }
+  }
+
+  // Check for any newly added types.
+  for (std::unique_ptr<ResourceTableType>& typeB : pkgB->types) {
+    ResourceTableType* typeA = pkgA->findType(typeB->type);
+    if (!typeA) {
+      std::stringstream strStream;
+      strStream << "new type " << pkgB->name << ":" << typeB->type;
+      emitDiffLine(apkB->getSource(), strStream.str());
+      diff = true;
     }
-    return diff;
+  }
+  return diff;
 }
 
-static bool emitResourceTableDiff(IAaptContext* context, LoadedApk* apkA, LoadedApk* apkB) {
-    ResourceTable* tableA = apkA->getResourceTable();
-    ResourceTable* tableB = apkB->getResourceTable();
-
-    bool diff = false;
-    for (std::unique_ptr<ResourceTablePackage>& pkgA : tableA->packages) {
-        ResourceTablePackage* pkgB = tableB->findPackage(pkgA->name);
-        if (!pkgB) {
-            std::stringstream strStream;
-            strStream << "missing package " << pkgA->name;
-            emitDiffLine(apkB->getSource(), strStream.str());
-            diff = true;
+static bool emitResourceTableDiff(IAaptContext* context, LoadedApk* apkA,
+                                  LoadedApk* apkB) {
+  ResourceTable* tableA = apkA->getResourceTable();
+  ResourceTable* tableB = apkB->getResourceTable();
+
+  bool diff = false;
+  for (std::unique_ptr<ResourceTablePackage>& pkgA : tableA->packages) {
+    ResourceTablePackage* pkgB = tableB->findPackage(pkgA->name);
+    if (!pkgB) {
+      std::stringstream strStream;
+      strStream << "missing package " << pkgA->name;
+      emitDiffLine(apkB->getSource(), strStream.str());
+      diff = true;
+    } else {
+      if (pkgA->id != pkgB->id) {
+        std::stringstream strStream;
+        strStream << "package '" << pkgA->name << "' has different id (";
+        if (pkgB->id) {
+          strStream << "0x" << std::hex << pkgB->id.value();
         } else {
-            if (pkgA->id != pkgB->id) {
-                std::stringstream strStream;
-                strStream << "package '" << pkgA->name << "' has different id (";
-                if (pkgB->id) {
-                    strStream << "0x" << std::hex << pkgB->id.value();
-                } else {
-                    strStream << "none";
-                }
-                strStream << " vs ";
-                if (pkgA->id) {
-                    strStream << "0x" << std::hex << pkgA->id.value();
-                } else {
-                    strStream << "none";
-                }
-                strStream << ")";
-                emitDiffLine(apkB->getSource(), strStream.str());
-                diff = true;
-            }
-            diff |= emitResourcePackageDiff(context, apkA, pkgA.get(), apkB, pkgB);
+          strStream << "none";
         }
-    }
-
-    // Check for any newly added packages.
-    for (std::unique_ptr<ResourceTablePackage>& pkgB : tableB->packages) {
-        ResourceTablePackage* pkgA = tableA->findPackage(pkgB->name);
-        if (!pkgA) {
-            std::stringstream strStream;
-            strStream << "new package " << pkgB->name;
-            emitDiffLine(apkB->getSource(), strStream.str());
-            diff = true;
+        strStream << " vs ";
+        if (pkgA->id) {
+          strStream << "0x" << std::hex << pkgA->id.value();
+        } else {
+          strStream << "none";
         }
+        strStream << ")";
+        emitDiffLine(apkB->getSource(), strStream.str());
+        diff = true;
+      }
+      diff |= emitResourcePackageDiff(context, apkA, pkgA.get(), apkB, pkgB);
+    }
+  }
+
+  // Check for any newly added packages.
+  for (std::unique_ptr<ResourceTablePackage>& pkgB : tableB->packages) {
+    ResourceTablePackage* pkgA = tableA->findPackage(pkgB->name);
+    if (!pkgA) {
+      std::stringstream strStream;
+      strStream << "new package " << pkgB->name;
+      emitDiffLine(apkB->getSource(), strStream.str());
+      diff = true;
     }
-    return diff;
+  }
+  return diff;
 }
 
 class ZeroingReferenceVisitor : public ValueVisitor {
-public:
-    using ValueVisitor::visit;
-
-    void visit(Reference* ref) override {
-        if (ref->name && ref->id) {
-            if (ref->id.value().packageId() == 0x7f) {
-                ref->id = {};
-            }
-        }
+ public:
+  using ValueVisitor::visit;
+
+  void visit(Reference* ref) override {
+    if (ref->name && ref->id) {
+      if (ref->id.value().packageId() == 0x7f) {
+        ref->id = {};
+      }
     }
+  }
 };
 
 static void zeroOutAppReferences(ResourceTable* table) {
-    ZeroingReferenceVisitor visitor;
-    visitAllValuesInTable(table, &visitor);
+  ZeroingReferenceVisitor visitor;
+  visitAllValuesInTable(table, &visitor);
 }
 
 int diff(const std::vector<StringPiece>& args) {
-    DiffContext context;
-
-    Flags flags;
-    if (!flags.parse("aapt2 diff", args, &std::cerr)) {
-        return 1;
-    }
-
-    if (flags.getArgs().size() != 2u) {
-        std::cerr << "must have two apks as arguments.\n\n";
-        flags.usage("aapt2 diff", &std::cerr);
-        return 1;
-    }
-
-    std::unique_ptr<LoadedApk> apkA = loadApkFromPath(&context, flags.getArgs()[0]);
-    std::unique_ptr<LoadedApk> apkB = loadApkFromPath(&context, flags.getArgs()[1]);
-    if (!apkA || !apkB) {
-        return 1;
-    }
-
-    // Zero out Application IDs in references.
-    zeroOutAppReferences(apkA->getResourceTable());
-    zeroOutAppReferences(apkB->getResourceTable());
-
-    if (emitResourceTableDiff(&context, apkA.get(), apkB.get())) {
-        // We emitted a diff, so return 1 (failure).
-        return 1;
-    }
-    return 0;
+  DiffContext context;
+
+  Flags flags;
+  if (!flags.parse("aapt2 diff", args, &std::cerr)) {
+    return 1;
+  }
+
+  if (flags.getArgs().size() != 2u) {
+    std::cerr << "must have two apks as arguments.\n\n";
+    flags.usage("aapt2 diff", &std::cerr);
+    return 1;
+  }
+
+  std::unique_ptr<LoadedApk> apkA =
+      loadApkFromPath(&context, flags.getArgs()[0]);
+  std::unique_ptr<LoadedApk> apkB =
+      loadApkFromPath(&context, flags.getArgs()[1]);
+  if (!apkA || !apkB) {
+    return 1;
+  }
+
+  // Zero out Application IDs in references.
+  zeroOutAppReferences(apkA->getResourceTable());
+  zeroOutAppReferences(apkB->getResourceTable());
+
+  if (emitResourceTableDiff(&context, apkA.get(), apkB.get())) {
+    // We emitted a diff, so return 1 (failure).
+    return 1;
+  }
+  return 0;
 }
 
-} // namespace aapt
+}  // namespace aapt