Roll ARCore SDK to 1.18, update device implementation

Changes:
- Roll ARCore SDK to version 1.18.
- Updated device implementation to opt in to use 30FPS.
- Updated ARCore APK version to 1.18.200603086 for the test bots to use.
- Updated ARCore session recording - now that the code opts in to use
30FPS, the recordings need to be done at 30FPS as well, otherwise the
camera configuration will fail.

~3kb since it needs to consume newly introduced APIs to configure AR
session. The remaining size increase can be mostly attributed to the
dependency growing (+8kb) and overhead (~4kb) - see breakdown for
details.

Binary-Size: Size increase is unavoidable. The product code increased by
Change-Id: Ied48a1d4e6203e697ff5489547f7e9a67be6af0c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2300808
Commit-Queue: Piotr Bialecki <bialpio@chromium.org>
Reviewed-by: Brian Sheedy <bsheedy@chromium.org>
Reviewed-by: Klaus Weidner <klausw@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Cr-Commit-Position: refs/heads/master@{#789689}

DEPS

@@ -995,7 +995,7 @@ deps = {
   },
 
   'src/third_party/arcore-android-sdk/src': {
-      'url': Var('chromium_git') + '/external/github.com/google-ar/arcore-android-sdk.git' + '@' + '765ca36d1d03e8d97bcb4d48d407277c3b503f21',
+      'url': Var('chromium_git') + '/external/github.com/google-ar/arcore-android-sdk.git' + '@' + '54861e38cceb406021fc8ece495f82387376af62',
       'condition': 'checkout_android',
   },
 
@@ -1003,7 +1003,7 @@ deps = {
       'packages': [
         {
           'package': 'chromium/third_party/arcore-android-sdk-client',
-          'version': 'Ki3Nxeov-cyGeHGIxrhG1teX7zYstsUtg1k-SAQ8CpAC',
+          'version': 'KFu2mHSzZr0ZNOlM_LG5AA5ZIi2_rICieWgkME9IUFYC',
         },
       ],
 

chrome/android/expectations/monochrome_public_bundle.AndroidManifest.expected

@@ -758,7 +758,7 @@
         android:name="com.google.android.gms.version"
         android:value="@integer/google_play_services_version"/>
     <meta-data android:name="com.google.ar.core" android:value="optional"/>
-    <meta-data android:name="com.google.ar.core.min_apk_version" android:value="190531000"/>
+    <meta-data android:name="com.google.ar.core.min_apk_version" android:value="200501000"/>
     <meta-data android:name="com.samsung.android.sdk.multiwindow.enable" android:value="true"/>
     <meta-data
         android:name="com.samsung.android.sdk.multiwindow.penwindow.enable"

chrome/android/expectations/trichrome_chrome_bundle.AndroidManifest.expected

@@ -712,7 +712,7 @@
         android:name="com.google.android.gms.version"
         android:value="@integer/google_play_services_version"/>
     <meta-data android:name="com.google.ar.core" android:value="optional"/>
-    <meta-data android:name="com.google.ar.core.min_apk_version" android:value="190531000"/>
+    <meta-data android:name="com.google.ar.core.min_apk_version" android:value="200501000"/>
     <meta-data android:name="com.samsung.android.sdk.multiwindow.enable" android:value="true"/>
     <meta-data
         android:name="com.samsung.android.sdk.multiwindow.penwindow.enable"

chrome/android/javatests/src/org/chromium/chrome/browser/vr/WebXrArHitTestTest.java

@@ -66,7 +66,7 @@ public class WebXrArHitTestTest {
     @Test
     @MediumTest
     @XrActivityRestriction({XrActivityRestriction.SupportedActivity.ALL})
-    @ArPlaybackFile("chrome/test/data/xr/ar_playback_datasets/floor_short_start_with_plane.mp4")
+    @ArPlaybackFile("chrome/test/data/xr/ar_playback_datasets/floor_session_12s_30fps.mp4")
     public void testHitTestSucceedsWithPlane() {
         mWebXrArTestFramework.loadFileAndAwaitInitialization(
                 "webxr_test_basic_hittest", PAGE_LOAD_TIMEOUT_S);

chrome/android/javatests/src/org/chromium/chrome/browser/vr/adding_new_tests.md

@@ -153,8 +153,8 @@ should be added to the `sources` list of the `chrome_test_ar_java`
 
 If you are adding an AR test and none of the existing datasets work for it, you
 can create and upload a new dataset that fits your needs. Dataset creation
-requires some internal tools, so contact either bsheedy@ or bialpio@ for
-instructions.
+requires some internal tools, see go/arcore-chrome-collect-recordings (internal
+link) or contact either bsheedy@ or bialpio@ for instructions.
 
 Once you have your playback dataset (.mp4 file), simply place it in
 `//chrome/test/data/xr/ar_playback_datasets/` and upload it using

chrome/android/javatests/src/org/chromium/chrome/browser/vr/util/ArTestRuleUtils.java

@@ -32,7 +32,7 @@ import java.util.concurrent.Callable;
  */
 public class ArTestRuleUtils extends XrTestRuleUtils {
     private static final String DEFAULT_PLAYBACK_FILEPATH =
-            "chrome/test/data/xr/ar_playback_datasets/empty_floor.mp4";
+            "chrome/test/data/xr/ar_playback_datasets/floor_session_12s_30fps.mp4";
     // This must be kept in sync with the ArCore session_settings entry in
     // //chrome/android/javatests/AndroidManifest_monochrome.xml.
     private static final String PLAYBACK_FILE_LOCATION =

chrome/browser/android/vr/arcore_device/arcore_impl.cc

@@ -353,6 +353,11 @@ bool ArCoreImpl::Initialize(
     return false;
   }
 
+  if (!ConfigureCamera(session.get())) {
+    DLOG(ERROR) << "Failed to configure camera";
+    return false;
+  }
+
   internal::ScopedArCoreObject<ArFrame*> frame;
   ArFrame_create(session.get(),
                  internal::ScopedArCoreObject<ArFrame*>::Receiver(frame).get());
@@ -382,6 +387,206 @@ bool ArCoreImpl::Initialize(
   return true;
 }
 
+bool ArCoreImpl::ConfigureCamera(ArSession* ar_session) const {
+  internal::ScopedArCoreObject<ArCameraConfigFilter*> camera_config_filter;
+  ArCameraConfigFilter_create(
+      ar_session, internal::ScopedArCoreObject<ArCameraConfigFilter*>::Receiver(
+                      camera_config_filter)
+                      .get());
+  if (!camera_config_filter.is_valid()) {
+    DLOG(ERROR) << "ArCameraConfigFilter_create failed";
+    return false;
+  }
+
+  // We only want to work at 30fps for now.
+  ArCameraConfigFilter_setTargetFps(ar_session, camera_config_filter.get(),
+                                    AR_CAMERA_CONFIG_TARGET_FPS_30);
+  // We do not care if depth sensor is available or not for now.
+  // The default depth sensor usage of the newly created filter is not
+  // documented, so let's set the filter explicitly to accept both cameras with
+  // and without depth sensors.
+  ArCameraConfigFilter_setDepthSensorUsage(
+      ar_session, camera_config_filter.get(),
+      AR_CAMERA_CONFIG_DEPTH_SENSOR_USAGE_REQUIRE_AND_USE |
+          AR_CAMERA_CONFIG_DEPTH_SENSOR_USAGE_DO_NOT_USE);
+
+  internal::ScopedArCoreObject<ArCameraConfigList*> camera_config_list;
+  ArCameraConfigList_create(
+      ar_session, internal::ScopedArCoreObject<ArCameraConfigList*>::Receiver(
+                      camera_config_list)
+                      .get());
+
+  if (!camera_config_list.is_valid()) {
+    DLOG(ERROR) << "ArCameraConfigList_create failed";
+    return false;
+  }
+
+  ArSession_getSupportedCameraConfigsWithFilter(
+      ar_session, camera_config_filter.get(), camera_config_list.get());
+  if (!camera_config_list.is_valid()) {
+    DLOG(ERROR) << "ArSession_getSupportedCameraConfigsWithFilter failed";
+    return false;
+  }
+
+  int32_t available_configs_count;
+  ArCameraConfigList_getSize(ar_session, camera_config_list.get(),
+                             &available_configs_count);
+
+  DVLOG(2) << __func__ << ": ARCore reported " << available_configs_count
+           << " available configurations";
+
+  std::vector<internal::ScopedArCoreObject<ArCameraConfig*>> available_configs;
+  available_configs.reserve(available_configs_count);
+  for (int32_t i = 0; i < available_configs_count; ++i) {
+    internal::ScopedArCoreObject<ArCameraConfig*> camera_config;
+    ArCameraConfig_create(
+        ar_session,
+        internal::ScopedArCoreObject<ArCameraConfig*>::Receiver(camera_config)
+            .get());
+
+    if (!camera_config.is_valid()) {
+      DVLOG(1) << __func__
+               << ": ArCameraConfig_create failed for camera config at index "
+               << i;
+      continue;
+    }
+
+    ArCameraConfigList_getItem(ar_session, camera_config_list.get(), i,
+                               camera_config.get());
+
+    ArCameraConfigFacingDirection facing_direction;
+    ArCameraConfig_getFacingDirection(ar_session, camera_config.get(),
+                                      &facing_direction);
+
+    if (facing_direction != AR_CAMERA_CONFIG_FACING_DIRECTION_BACK) {
+      DVLOG(2)
+          << __func__
+          << ": camera config does not refer to back-facing camera, ignoring";
+      continue;
+    }
+
+#if DCHECK_IS_ON()
+    {
+      int32_t tex_width, tex_height;
+      ArCameraConfig_getTextureDimensions(ar_session, camera_config.get(),
+                                          &tex_width, &tex_height);
+
+      int32_t img_width, img_height;
+      ArCameraConfig_getImageDimensions(ar_session, camera_config.get(),
+                                        &img_width, &img_height);
+
+      uint32_t depth_sensor_usage;
+      ArCameraConfig_getDepthSensorUsage(ar_session, camera_config.get(),
+                                         &depth_sensor_usage);
+
+      DVLOG(3) << __func__
+               << ": matching camera config found, texture dimensions="
+               << tex_width << "x" << tex_height
+               << ", image dimensions= " << img_width << "x" << img_height
+               << ", depth sensor usage=" << depth_sensor_usage;
+    }
+#endif
+
+    available_configs.push_back(std::move(camera_config));
+  }
+
+  if (available_configs.empty()) {
+    DLOG(ERROR) << "No matching configs found";
+    return false;
+  }
+
+  auto best_config = std::max_element(
+      available_configs.begin(), available_configs.end(),
+      [ar_session](const internal::ScopedArCoreObject<ArCameraConfig*>& lhs,
+                   const internal::ScopedArCoreObject<ArCameraConfig*>& rhs) {
+        // true means that lhs is less than rhs
+
+        // We'll prefer the configs with higher total resolution (GPU first,
+        // then CPU), everything else does not matter for us now, but we will
+        // weakly prefer the cameras that support depth sensor (it will be used
+        // as a tie-breaker).
+
+        {
+          int32_t lhs_tex_width, lhs_tex_height;
+          int32_t rhs_tex_width, rhs_tex_height;
+
+          ArCameraConfig_getTextureDimensions(ar_session, lhs.get(),
+                                              &lhs_tex_width, &lhs_tex_height);
+          ArCameraConfig_getTextureDimensions(ar_session, rhs.get(),
+                                              &rhs_tex_width, &rhs_tex_height);
+
+          if (lhs_tex_width * lhs_tex_height !=
+              rhs_tex_width * rhs_tex_height) {
+            return lhs_tex_width * lhs_tex_height <
+                   rhs_tex_width * rhs_tex_height;
+          }
+        }
+
+        {
+          int32_t lhs_img_width, lhs_img_height;
+          int32_t rhs_img_width, rhs_img_height;
+
+          ArCameraConfig_getImageDimensions(ar_session, lhs.get(),
+                                            &lhs_img_width, &lhs_img_height);
+          ArCameraConfig_getImageDimensions(ar_session, rhs.get(),
+                                            &rhs_img_width, &rhs_img_height);
+
+          if (lhs_img_width * lhs_img_height !=
+              rhs_img_width * rhs_img_height) {
+            return lhs_img_width * lhs_img_height <
+                   rhs_img_width * rhs_img_height;
+          }
+        }
+
+        {
+          uint32_t lhs_depth_sensor_usage;
+          uint32_t rhs_depth_sensor_usage;
+
+          ArCameraConfig_getDepthSensorUsage(ar_session, lhs.get(),
+                                             &lhs_depth_sensor_usage);
+          ArCameraConfig_getDepthSensorUsage(ar_session, rhs.get(),
+                                             &rhs_depth_sensor_usage);
+
+          bool lhs_has_depth =
+              lhs_depth_sensor_usage &
+              AR_CAMERA_CONFIG_DEPTH_SENSOR_USAGE_REQUIRE_AND_USE;
+          bool rhs_has_depth =
+              rhs_depth_sensor_usage &
+              AR_CAMERA_CONFIG_DEPTH_SENSOR_USAGE_REQUIRE_AND_USE;
+
+          return lhs_has_depth < rhs_has_depth;
+        }
+      });
+
+#if DCHECK_IS_ON()
+  {
+    int32_t tex_width, tex_height;
+    ArCameraConfig_getTextureDimensions(ar_session, best_config->get(),
+                                        &tex_width, &tex_height);
+
+    int32_t img_width, img_height;
+    ArCameraConfig_getImageDimensions(ar_session, best_config->get(),
+                                      &img_width, &img_height);
+
+    uint32_t depth_sensor_usage;
+    ArCameraConfig_getDepthSensorUsage(ar_session, best_config->get(),
+                                       &depth_sensor_usage);
+    DVLOG(3) << __func__
+             << ": selected camera config with texture dimensions=" << tex_width
+             << "x" << tex_height << ", image dimensions=" << img_width << "x"
+             << img_height << ", depth sensor usage=" << depth_sensor_usage;
+  }
+#endif
+
+  ArStatus status = ArSession_setCameraConfig(ar_session, best_config->get());
+  if (status != AR_SUCCESS) {
+    DLOG(ERROR) << "ArSession_setCameraConfig failed: " << status;
+    return false;
+  }
+
+  return true;
+}
+
 void ArCoreImpl::SetCameraTexture(GLuint camera_texture_id) {
   DCHECK(IsOnGlThread());
   DCHECK(arcore_session_.is_valid());

chrome/browser/android/vr/arcore_device/arcore_impl.h

@@ -276,6 +276,11 @@ class ArCoreImpl : public ArCore {
       const base::TimeTicks& frame_time,
       FunctionType&& create_anchor_function);
 
+  // Helper, attempts to configure ArSession's camera for use. Note that this is
+  // happening during initialization, before arcore_session_ is set.
+  // Returns true if configuration succeeded, false otherwise.
+  bool ConfigureCamera(ArSession* ar_session) const;
+
   // Must be last.
   base::WeakPtrFactory<ArCoreImpl> weak_ptr_factory_{this};
   DISALLOW_COPY_AND_ASSIGN(ArCoreImpl);

chrome/browser/android/vr/arcore_device/arcore_shim.cc

@@ -26,6 +26,20 @@ namespace {
   DO(ArCamera_getProjectionMatrix)                                 \
   DO(ArCamera_getTrackingState)                                    \
   DO(ArCamera_getViewMatrix)                                       \
+  DO(ArCameraConfig_create)                                        \
+  DO(ArCameraConfig_destroy)                                       \
+  DO(ArCameraConfig_getDepthSensorUsage)                           \
+  DO(ArCameraConfig_getFacingDirection)                            \
+  DO(ArCameraConfig_getImageDimensions)                            \
+  DO(ArCameraConfig_getTextureDimensions)                          \
+  DO(ArCameraConfigFilter_create)                                  \
+  DO(ArCameraConfigFilter_destroy)                                 \
+  DO(ArCameraConfigFilter_setDepthSensorUsage)                     \
+  DO(ArCameraConfigFilter_setTargetFps)                            \
+  DO(ArCameraConfigList_create)                                    \
+  DO(ArCameraConfigList_destroy)                                   \
+  DO(ArCameraConfigList_getItem)                                   \
+  DO(ArCameraConfigList_getSize)                                   \
   DO(ArConfig_create)                                              \
   DO(ArConfig_destroy)                                             \
   DO(ArConfig_getLightEstimationMode)                              \
@@ -72,8 +86,10 @@ namespace {
   DO(ArSession_enableIncognitoMode_private)                        \
   DO(ArSession_getAllAnchors)                                      \
   DO(ArSession_getAllTrackables)                                   \
+  DO(ArSession_getSupportedCameraConfigsWithFilter)                \
   DO(ArSession_pause)                                              \
   DO(ArSession_resume)                                             \
+  DO(ArSession_setCameraConfig)                                    \
   DO(ArSession_setCameraTextureName)                               \
   DO(ArSession_setDisplayGeometry)                                 \
   DO(ArSession_update)                                             \
@@ -156,7 +172,6 @@ bool IsArCoreSupported() {
 
 }  // namespace vr
 
-
 void ArAnchorList_acquireItem(const ArSession* session,
                               const ArAnchorList* anchor_list,
                               int32_t index,
@@ -231,6 +246,93 @@ void ArCamera_getViewMatrix(const ArSession* session,
   return g_arcore_api->impl_ArCamera_getViewMatrix(session, camera, out_matrix);
 }
 
+void ArCameraConfig_create(const ArSession* session,
+                           ArCameraConfig** out_camera_config) {
+  return g_arcore_api->impl_ArCameraConfig_create(session, out_camera_config);
+}
+
+void ArCameraConfig_destroy(ArCameraConfig* camera_config) {
+  return g_arcore_api->impl_ArCameraConfig_destroy(camera_config);
+}
+
+void ArCameraConfig_getDepthSensorUsage(const ArSession* session,
+                                        const ArCameraConfig* camera_config,
+                                        uint32_t* out_depth_sensor_usage) {
+  return g_arcore_api->impl_ArCameraConfig_getDepthSensorUsage(
+      session, camera_config, out_depth_sensor_usage);
+}
+
+void ArCameraConfig_getFacingDirection(
+    const ArSession* session,
+    const ArCameraConfig* camera_config,
+    ArCameraConfigFacingDirection* out_facing) {
+  return g_arcore_api->impl_ArCameraConfig_getFacingDirection(
+      session, camera_config, out_facing);
+}
+
+void ArCameraConfig_getImageDimensions(const ArSession* session,
+                                       const ArCameraConfig* camera_config,
+                                       int32_t* out_width,
+                                       int32_t* out_height) {
+  return g_arcore_api->impl_ArCameraConfig_getImageDimensions(
+      session, camera_config, out_width, out_height);
+}
+
+void ArCameraConfig_getTextureDimensions(const ArSession* session,
+                                         const ArCameraConfig* camera_config,
+                                         int32_t* out_width,
+                                         int32_t* out_height) {
+  return g_arcore_api->impl_ArCameraConfig_getTextureDimensions(
+      session, camera_config, out_width, out_height);
+}
+
+void ArCameraConfigFilter_create(const ArSession* session,
+                                 ArCameraConfigFilter** out_filter) {
+  return g_arcore_api->impl_ArCameraConfigFilter_create(session, out_filter);
+}
+
+void ArCameraConfigFilter_destroy(ArCameraConfigFilter* filter) {
+  return g_arcore_api->impl_ArCameraConfigFilter_destroy(filter);
+}
+
+void ArCameraConfigFilter_setDepthSensorUsage(
+    const ArSession* session,
+    ArCameraConfigFilter* filter,
+    uint32_t depth_sensor_usage_filters) {
+  return g_arcore_api->impl_ArCameraConfigFilter_setDepthSensorUsage(
+      session, filter, depth_sensor_usage_filters);
+}
+
+void ArCameraConfigFilter_setTargetFps(const ArSession* session,
+                                       ArCameraConfigFilter* filter,
+                                       const uint32_t fps_filters) {
+  return g_arcore_api->impl_ArCameraConfigFilter_setTargetFps(session, filter,
+                                                              fps_filters);
+}
+
+void ArCameraConfigList_create(const ArSession* session,
+                               ArCameraConfigList** out_list) {
+  return g_arcore_api->impl_ArCameraConfigList_create(session, out_list);
+}
+
+void ArCameraConfigList_destroy(ArCameraConfigList* list) {
+  return g_arcore_api->impl_ArCameraConfigList_destroy(list);
+}
+
+void ArCameraConfigList_getItem(const ArSession* session,
+                                const ArCameraConfigList* list,
+                                int32_t index,
+                                ArCameraConfig* out_camera_config) {
+  return g_arcore_api->impl_ArCameraConfigList_getItem(session, list, index,
+                                                       out_camera_config);
+}
+
+void ArCameraConfigList_getSize(const ArSession* session,
+                                const ArCameraConfigList* list,
+                                int32_t* out_size) {
+  return g_arcore_api->impl_ArCameraConfigList_getSize(session, list, out_size);
+}
+
 void ArConfig_create(const ArSession* session, ArConfig** out_config) {
   return g_arcore_api->impl_ArConfig_create(session, out_config);
 }
@@ -575,6 +677,14 @@ void ArSession_getAllTrackables(const ArSession* session,
                                                        out_trackable_list);
 }
 
+void ArSession_getSupportedCameraConfigsWithFilter(
+    const ArSession* session,
+    const ArCameraConfigFilter* filter,
+    ArCameraConfigList* list) {
+  return g_arcore_api->impl_ArSession_getSupportedCameraConfigsWithFilter(
+      session, filter, list);
+}
+
 ArStatus ArSession_pause(ArSession* session) {
   return g_arcore_api->impl_ArSession_pause(session);
 }
@@ -583,6 +693,11 @@ ArStatus ArSession_resume(ArSession* session) {
   return g_arcore_api->impl_ArSession_resume(session);
 }
 
+ArStatus ArSession_setCameraConfig(const ArSession* session,
+                                   const ArCameraConfig* camera_config) {
+  return g_arcore_api->impl_ArSession_setCameraConfig(session, camera_config);
+}
+
 void ArSession_setCameraTextureName(ArSession* session, uint32_t texture_id) {
   return g_arcore_api->impl_ArSession_setCameraTextureName(session, texture_id);
 }

chrome/browser/android/vr/arcore_device/scoped_arcore_objects.h

@@ -32,6 +32,24 @@ void inline ScopedGenericArObject<ArConfig*>::Free(ArConfig* ar_config) {
   ArConfig_destroy(ar_config);
 }
 
+template <>
+void inline ScopedGenericArObject<ArCameraConfig*>::Free(
+    ArCameraConfig* ar_camera_config) {
+  ArCameraConfig_destroy(ar_camera_config);
+}
+
+template <>
+void inline ScopedGenericArObject<ArCameraConfigFilter*>::Free(
+    ArCameraConfigFilter* ar_camera_config_filter) {
+  ArCameraConfigFilter_destroy(ar_camera_config_filter);
+}
+
+template <>
+void inline ScopedGenericArObject<ArCameraConfigList*>::Free(
+    ArCameraConfigList* ar_camera_config_list) {
+  ArCameraConfigList_destroy(ar_camera_config_list);
+}
+
 template <>
 void inline ScopedGenericArObject<ArPose*>::Free(ArPose* ar_pose) {
   ArPose_destroy(ar_pose);

chrome/test/data/xr/ar_playback_datasets/floor_session_12s_30fps.mp4.sha1

+ab81c1c2be25a6022f99de47affee40ae0c51ff1
\ No newline at end of file

third_party/arcore-android-sdk-client/BUILD.gn

@@ -5,8 +5,8 @@
 import("//build/config/android/rules.gni")
 
 android_aar_prebuilt("com_google_ar_core_java") {
-  aar_path = "core-partner_chrome-1.10.0.aar"
-  info_path = "core-partner_chrome-1.10.0.info"
+  aar_path = "core-1.18.0.aar"
+  info_path = "core-1.18.0.info"
   extract_native_libraries = true
 
   ignore_proguard_configs = true

third_party/arcore-android-sdk-client/README.chromium

 Name: ARCore SDK client library for Chrome
 Short Name: com.google.ar:core-partner_chrome
 URL: https://developers.google.com/ar/develop/java/enable-arcore#dependencies
-Version: 1.10
+Version: 1.18
 License: Apache 2.0
 License File: LICENSE
 Security Critical: yes
@@ -27,6 +27,7 @@ The LICENSE file is taken from
  * https://www.apache.org/licenses/LICENSE-2.0.txt
 
 Changes:
+2020-07-13 - Upgraded SDK binaries to v1.18.
 2020-01-23 - Added override for proguard configs brought by ARCore SDK's .aar.
              This was achieved by extracting proguard.txt from
              core-partner_chrome-1.10.0.aar and commenting out offending

third_party/arcore-android-sdk-client/cipd.yaml

 package: chromium/third_party/arcore-android-sdk-client
 description: ARCore SDK client binaries.
 data:
-  - file: core-partner_chrome-1.10.0.aar
+  - file: core-1.18.0.aar

third_party/arcore-android-sdk-client/core-partner_chrome-1.10.0.info → third_party/arcore-android-sdk-client/core-1.18.0.info

@@ -20,7 +20,7 @@ native_libraries = [
 ]
 resources = [
   "res/layout/__arcore_education.xml",
-  "res/raw/keep.xml",
+  "res/raw/keep_arcore.xml",
   "res/values-af/values.xml",
   "res/values-am/values.xml",
   "res/values-ar-rEG/values.xml",

third_party/arcore-android-sdk/README.chromium

 Name: ARCore SDK
 Short Name: arcore
 URL: https://github.com/google-ar/arcore-android-sdk
-Version: 1.5
+Version: 1.18
 License: Apache 2.0
 License File: LICENSE
 Security Critical: yes
@@ -10,20 +10,22 @@ Description:
 The ARCore Android SDK provides augmented reality capabilities to Android
 devices.
 
+This dependency is needed to obtain the header file that is required to use the
+ARCore SDK. The actual client binaries can be found in
+third_party/arcore-android-sdk-client.
+
 Local Modifications:
 Added BUILD.gn for compilation in chrome.
 
 Added the test-apks/ subdirectory for storing production versions of AR APKs,
 namely ArCore, for testing.
 
-IMPORTANT: make sure to change chrome/android/java/AndroidManifest.xml
-com.google.ar.core.min_apk_version attribute if a newer version of the
-ARCore APK is required to maintain compatibility with this SDK.
-
 The LICENSE file is taken from
  * https://github.com/google-ar/arcore-unity-sdk/blob/master/LICENSE
 
 Changes:
+2020-07-13 - Upgrade SDK to v1.18.
+             Upgrade test-apks/arcore_current.apk to v1.18.
 2019-12-18 - Upgrade test-apks/arcore_current.apk to v1.14.
 2019-07-22 - Upgrade test-apks/arcore_current.apk to v1.10.
 2019-07-18 - Upgrade SDK to v1.10.

third_party/arcore-android-sdk/test-apks/arcore/apk_version_history.txt

@@ -4,3 +4,4 @@ v1.6 c79453295a1188afc8911d1760f297fef9187910
 v1.8 86552409cbb27f39204012cac7accf27a42b63ec
 v1.10 0dbc7e2063965f19143b0db577ce4b10bcbe1e9b
 v1.14 7f864ce993380af9c52c12e6ec69b1bfe1c12cc6
+v1.18 2f386ac4b7b635354aa8390cc931e2fcc0fb57fc
\ No newline at end of file

third_party/arcore-android-sdk/test-apks/arcore/arcore_current.apk.sha1

-7f864ce993380af9c52c12e6ec69b1bfe1c12cc6
+2f386ac4b7b635354aa8390cc931e2fcc0fb57fc
\ No newline at end of file