Update Icing from upstream.

Descriptions:
========================================================================
Set overall index latency
========================================================================
Change GetUsageScores return type to optional.
========================================================================
Upstream fix to thread-safety annotation for cached_break_iterator_
========================================================================

Bug: 259744228
Change-Id: Ia7a5032fd7655db773e311173f5735e4451b30c1

10 files changed, 130 insertions, 82 deletions

diff --git a/icing/index/index-processor.cc b/icing/index/index-processor.cc
index 34988f5..9a773e8 100644
--- a/icing/index/index-processor.cc
+++ b/icing/index/index-processor.cc
@@ -14,11 +14,7 @@
 
 #include "icing/index/index-processor.h"
 
-#include <cstdint>
 #include <memory>
-#include <string>
-#include <string_view>
-#include <vector>
 
 #include "icing/text_classifier/lib3/utils/base/status.h"
 #include "icing/index/data-indexing-handler.h"
@@ -33,12 +29,18 @@ namespace lib {
 libtextclassifier3::Status IndexProcessor::IndexDocument(
     const TokenizedDocument& tokenized_document, DocumentId document_id,
     PutDocumentStatsProto* put_document_stats) {
-  // TODO(b/259744228): set overall index latency.
+  std::unique_ptr<Timer> index_timer = clock_.GetNewTimer();
+
   for (auto& data_indexing_handler : data_indexing_handlers_) {
     ICING_RETURN_IF_ERROR(data_indexing_handler->Handle(
         tokenized_document, document_id, recovery_mode_, put_document_stats));
   }
 
+  if (put_document_stats != nullptr) {
+    put_document_stats->set_index_latency_ms(
+        index_timer->GetElapsedMilliseconds());
+  }
+
   return libtextclassifier3::Status::OK;
 }
 
diff --git a/icing/index/string-section-indexing-handler.cc b/icing/index/string-section-indexing-handler.cc
index 83a2687..a992568 100644
--- a/icing/index/string-section-indexing-handler.cc
+++ b/icing/index/string-section-indexing-handler.cc
@@ -121,9 +121,7 @@ libtextclassifier3::Status StringSectionIndexingHandler::Handle(
   }
 
   if (put_document_stats != nullptr) {
-    // TODO(b/259744228): switch to set individual index latency.
-    put_document_stats->set_index_latency_ms(
-        index_timer->GetElapsedMilliseconds());
+    // TODO(b/259744228): set term index latency.
     put_document_stats->mutable_tokenization_stats()->set_num_tokens_indexed(
         num_tokens);
   }
diff --git a/icing/scoring/advanced_scoring/score-expression.cc b/icing/scoring/advanced_scoring/score-expression.cc
index 4df0710..7a8f046 100644
--- a/icing/scoring/advanced_scoring/score-expression.cc
+++ b/icing/scoring/advanced_scoring/score-expression.cc
@@ -17,6 +17,8 @@
 #include <numeric>
 #include <vector>
 
+#include "icing/absl_ports/canonical_errors.h"
+
 namespace icing {
 namespace lib {
 
@@ -362,25 +364,28 @@ libtextclassifier3::StatusOr<double> DocumentFunctionScoreExpression::eval(
         return absl_ports::InvalidArgumentError(
             "Usage type must be an integer from 1 to 3");
       }
-      ICING_ASSIGN_OR_RETURN(
-          UsageStore::UsageScores usage_scores,
-          document_store_.GetUsageScores(hit_info.document_id()),
-          default_score_);
+      std::optional<UsageStore::UsageScores> usage_scores =
+          document_store_.GetUsageScores(hit_info.document_id());
+      if (!usage_scores) {
+        // If there's no UsageScores entry present for this doc, then just
+        // treat it as a default instance.
+        usage_scores = UsageStore::UsageScores();
+      }
       if (function_type_ == FunctionType::kUsageCount) {
         if (usage_type == 1) {
-          return usage_scores.usage_type1_count;
+          return usage_scores->usage_type1_count;
         } else if (usage_type == 2) {
-          return usage_scores.usage_type2_count;
+          return usage_scores->usage_type2_count;
         } else {
-          return usage_scores.usage_type3_count;
+          return usage_scores->usage_type3_count;
         }
       }
       if (usage_type == 1) {
-        return usage_scores.usage_type1_last_used_timestamp_s * 1000.0;
+        return usage_scores->usage_type1_last_used_timestamp_s * 1000.0;
       } else if (usage_type == 2) {
-        return usage_scores.usage_type2_last_used_timestamp_s * 1000.0;
+        return usage_scores->usage_type2_last_used_timestamp_s * 1000.0;
       } else {
-        return usage_scores.usage_type3_last_used_timestamp_s * 1000.0;
+        return usage_scores->usage_type3_last_used_timestamp_s * 1000.0;
       }
     }
   }
diff --git a/icing/scoring/scorer-factory.cc b/icing/scoring/scorer-factory.cc
index c647642..d4d8b79 100644
--- a/icing/scoring/scorer-factory.cc
+++ b/icing/scoring/scorer-factory.cc
@@ -115,23 +115,27 @@ class UsageScorer : public Scorer {
 
   double GetScore(const DocHitInfo& hit_info,
                   const DocHitInfoIterator*) override {
-    ICING_ASSIGN_OR_RETURN(
-        UsageStore::UsageScores usage_scores,
-        document_store_.GetUsageScores(hit_info.document_id()), default_score_);
+    std::optional<UsageStore::UsageScores> usage_scores =
+        document_store_.GetUsageScores(hit_info.document_id());
+    if (!usage_scores) {
+      // If there's no UsageScores entry present for this doc, then just
+      // treat it as a default instance.
+      usage_scores = UsageStore::UsageScores();
+    }
 
     switch (ranking_strategy_) {
       case ScoringSpecProto::RankingStrategy::USAGE_TYPE1_COUNT:
-        return usage_scores.usage_type1_count;
+        return usage_scores->usage_type1_count;
       case ScoringSpecProto::RankingStrategy::USAGE_TYPE2_COUNT:
-        return usage_scores.usage_type2_count;
+        return usage_scores->usage_type2_count;
       case ScoringSpecProto::RankingStrategy::USAGE_TYPE3_COUNT:
-        return usage_scores.usage_type3_count;
+        return usage_scores->usage_type3_count;
       case ScoringSpecProto::RankingStrategy::USAGE_TYPE1_LAST_USED_TIMESTAMP:
-        return usage_scores.usage_type1_last_used_timestamp_s * 1000.0;
+        return usage_scores->usage_type1_last_used_timestamp_s * 1000.0;
       case ScoringSpecProto::RankingStrategy::USAGE_TYPE2_LAST_USED_TIMESTAMP:
-        return usage_scores.usage_type2_last_used_timestamp_s * 1000.0;
+        return usage_scores->usage_type2_last_used_timestamp_s * 1000.0;
       case ScoringSpecProto::RankingStrategy::USAGE_TYPE3_LAST_USED_TIMESTAMP:
-        return usage_scores.usage_type3_last_used_timestamp_s * 1000.0;
+        return usage_scores->usage_type3_last_used_timestamp_s * 1000.0;
       default:
         // This shouldn't happen if this scorer is used correctly.
         return default_score_;
diff --git a/icing/store/document-store.cc b/icing/store/document-store.cc
index 710ff58..a81ae4b 100644
--- a/icing/store/document-store.cc
+++ b/icing/store/document-store.cc
@@ -17,6 +17,7 @@
 #include <cstdint>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <unordered_map>
@@ -1297,13 +1298,25 @@ DocumentStore::GetCorpusAssociatedScoreDataToUpdate(CorpusId corpus_id) const {
   return corpus_scoring_data_or.status();
 }
 
-libtextclassifier3::StatusOr<UsageStore::UsageScores>
-DocumentStore::GetUsageScores(DocumentId document_id) const {
-  if (!GetAliveDocumentFilterData(document_id)) {
-    return absl_ports::NotFoundError(IcingStringUtil::StringPrintf(
-        "Can't get usage scores, document id '%d' doesn't exist", document_id));
+// TODO(b/273826815): Decide on and adopt a consistent pattern for handling
+// NOT_FOUND 'errors' returned by our internal classes.
+std::optional<UsageStore::UsageScores> DocumentStore::GetUsageScores(
+    DocumentId document_id) const {
+  std::optional<DocumentFilterData> opt =
+      GetAliveDocumentFilterData(document_id);
+  if (!opt) {
+    return std::nullopt;
+  }
+  if (document_id >= usage_store_->num_elements()) {
+    return std::nullopt;
+  }
+  auto usage_scores_or = usage_store_->GetUsageScores(document_id);
+  if (!usage_scores_or.ok()) {
+    ICING_LOG(ERROR) << "Error retrieving usage for " << document_id << ": "
+                     << usage_scores_or.status().error_message();
+    return std::nullopt;
   }
-  return usage_store_->GetUsageScores(document_id);
+  return std::move(usage_scores_or).ValueOrDie();
 }
 
 libtextclassifier3::Status DocumentStore::ReportUsage(
diff --git a/icing/store/document-store.h b/icing/store/document-store.h
index 7c414d7..6feed2e 100644
--- a/icing/store/document-store.h
+++ b/icing/store/document-store.h
@@ -336,9 +336,8 @@ class DocumentStore {
   //
   // Returns:
   //   UsageScores on success
-  //   NOT_FOUND if document_id no longer exists.
-  //   INVALID_ARGUMENT if document_id is invalid
-  libtextclassifier3::StatusOr<UsageStore::UsageScores> GetUsageScores(
+  //   nullopt if there are no usage scores stored for the requested docid.
+  std::optional<UsageStore::UsageScores> GetUsageScores(
       DocumentId document_id) const;
 
   // Reports usage. The corresponding usage scores of the specified document in
diff --git a/icing/store/document-store_test.cc b/icing/store/document-store_test.cc
index 81da191..1273c67 100644
--- a/icing/store/document-store_test.cc
+++ b/icing/store/document-store_test.cc
@@ -18,6 +18,7 @@
 #include <filesystem>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "icing/text_classifier/lib3/utils/base/status.h"
@@ -1839,8 +1840,9 @@ TEST_F(DocumentStoreTest, DeleteShouldPreventUsageScores) {
 
   UsageStore::UsageScores expected_scores;
   expected_scores.usage_type1_count = 1;
-  ASSERT_THAT(doc_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(UsageStore::UsageScores actual_scores,
+                                    doc_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Delete the document.
   ICING_ASSERT_OK(doc_store->Delete("icing", "email/1"));
@@ -1851,9 +1853,7 @@ TEST_F(DocumentStoreTest, DeleteShouldPreventUsageScores) {
       StatusIs(libtextclassifier3::StatusCode::NOT_FOUND,
                HasSubstr("Couldn't report usage on a nonexistent document")));
 
-  ASSERT_THAT(doc_store->GetUsageScores(document_id),
-              StatusIs(libtextclassifier3::StatusCode::NOT_FOUND,
-                       HasSubstr("Can't get usage scores")));
+  EXPECT_FALSE(doc_store->GetUsageScores(document_id));
 }
 
 TEST_F(DocumentStoreTest, ExpirationShouldPreventUsageScores) {
@@ -1887,8 +1887,9 @@ TEST_F(DocumentStoreTest, ExpirationShouldPreventUsageScores) {
 
   UsageStore::UsageScores expected_scores;
   expected_scores.usage_type1_count = 1;
-  ASSERT_THAT(doc_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(UsageStore::UsageScores actual_scores,
+                                    doc_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Some arbitrary time past the document's creation time (10) + ttl (100)
   fake_clock_.SetSystemTimeMilliseconds(200);
@@ -1899,9 +1900,7 @@ TEST_F(DocumentStoreTest, ExpirationShouldPreventUsageScores) {
       StatusIs(libtextclassifier3::StatusCode::NOT_FOUND,
                HasSubstr("Couldn't report usage on a nonexistent document")));
 
-  ASSERT_THAT(doc_store->GetUsageScores(document_id),
-              StatusIs(libtextclassifier3::StatusCode::NOT_FOUND,
-                       HasSubstr("Can't get usage scores")));
+  EXPECT_FALSE(doc_store->GetUsageScores(document_id));
 }
 
 TEST_F(DocumentStoreTest,
@@ -2869,8 +2868,10 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTimestampsAndGetUsageScores) {
   UsageStore::UsageScores expected_scores;
   expected_scores.usage_type1_last_used_timestamp_s = 1;
   ++expected_scores.usage_type1_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      UsageStore::UsageScores actual_scores,
+      document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Report usage with type 1 and time 5, time should be updated.
   UsageReport usage_report_type1_time5 = CreateUsageReport(
@@ -2880,8 +2881,9 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTimestampsAndGetUsageScores) {
 
   expected_scores.usage_type1_last_used_timestamp_s = 5;
   ++expected_scores.usage_type1_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores, document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Report usage with type 2 and time 1.
   UsageReport usage_report_type2_time1 = CreateUsageReport(
@@ -2891,8 +2893,9 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTimestampsAndGetUsageScores) {
 
   expected_scores.usage_type2_last_used_timestamp_s = 1;
   ++expected_scores.usage_type2_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores, document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Report usage with type 2 and time 5.
   UsageReport usage_report_type2_time5 = CreateUsageReport(
@@ -2902,8 +2905,9 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTimestampsAndGetUsageScores) {
 
   expected_scores.usage_type2_last_used_timestamp_s = 5;
   ++expected_scores.usage_type2_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores, document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Report usage with type 3 and time 1.
   UsageReport usage_report_type3_time1 = CreateUsageReport(
@@ -2913,8 +2917,9 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTimestampsAndGetUsageScores) {
 
   expected_scores.usage_type3_last_used_timestamp_s = 1;
   ++expected_scores.usage_type3_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores, document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Report usage with type 3 and time 5.
   UsageReport usage_report_type3_time5 = CreateUsageReport(
@@ -2924,8 +2929,9 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTimestampsAndGetUsageScores) {
 
   expected_scores.usage_type3_last_used_timestamp_s = 5;
   ++expected_scores.usage_type3_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores, document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 }
 
 TEST_F(DocumentStoreTest, ReportUsageWithDifferentTypesAndGetUsageScores) {
@@ -2947,8 +2953,10 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTypesAndGetUsageScores) {
 
   UsageStore::UsageScores expected_scores;
   ++expected_scores.usage_type1_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      UsageStore::UsageScores actual_scores,
+      document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Report usage with type 2.
   UsageReport usage_report_type2 = CreateUsageReport(
@@ -2957,8 +2965,9 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTypesAndGetUsageScores) {
   ICING_ASSERT_OK(document_store->ReportUsage(usage_report_type2));
 
   ++expected_scores.usage_type2_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores, document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Report usage with type 3.
   UsageReport usage_report_type3 = CreateUsageReport(
@@ -2967,8 +2976,9 @@ TEST_F(DocumentStoreTest, ReportUsageWithDifferentTypesAndGetUsageScores) {
   ICING_ASSERT_OK(document_store->ReportUsage(usage_report_type3));
 
   ++expected_scores.usage_type3_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores, document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 }
 
 TEST_F(DocumentStoreTest, UsageScoresShouldNotBeClearedOnChecksumMismatch) {
@@ -2992,8 +3002,10 @@ TEST_F(DocumentStoreTest, UsageScoresShouldNotBeClearedOnChecksumMismatch) {
     ICING_ASSERT_OK(document_store->ReportUsage(usage_report_type1));
 
     ++expected_scores.usage_type1_count;
-    ASSERT_THAT(document_store->GetUsageScores(document_id),
-                IsOkAndHolds(expected_scores));
+    ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+        UsageStore::UsageScores actual_scores,
+        document_store->GetUsageScores(document_id));
+    EXPECT_THAT(actual_scores, Eq(expected_scores));
   }
 
   CorruptDocStoreHeaderChecksumFile();
@@ -3006,8 +3018,10 @@ TEST_F(DocumentStoreTest, UsageScoresShouldNotBeClearedOnChecksumMismatch) {
       std::move(create_result.document_store);
 
   // Usage scores should be the same.
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      UsageStore::UsageScores actual_scores,
+      document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 }
 
 TEST_F(DocumentStoreTest, UsageScoresShouldBeAvailableAfterDataLoss) {
@@ -3031,8 +3045,10 @@ TEST_F(DocumentStoreTest, UsageScoresShouldBeAvailableAfterDataLoss) {
     ICING_ASSERT_OK(document_store->ReportUsage(usage_report_type1));
 
     ++expected_scores.usage_type1_count;
-    ASSERT_THAT(document_store->GetUsageScores(document_id),
-                IsOkAndHolds(expected_scores));
+    ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+        UsageStore::UsageScores actual_scores,
+        document_store->GetUsageScores(document_id));
+    EXPECT_THAT(actual_scores, Eq(expected_scores));
   }
 
   // "Corrupt" the content written in the log by adding non-checksummed data to
@@ -3056,8 +3072,10 @@ TEST_F(DocumentStoreTest, UsageScoresShouldBeAvailableAfterDataLoss) {
       std::move(create_result.document_store);
 
   // Usage scores should still be available.
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      UsageStore::UsageScores actual_scores,
+      document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 }
 
 TEST_F(DocumentStoreTest, UsageScoresShouldBeCopiedOverToUpdatedDocument) {
@@ -3080,8 +3098,10 @@ TEST_F(DocumentStoreTest, UsageScoresShouldBeCopiedOverToUpdatedDocument) {
 
   UsageStore::UsageScores expected_scores;
   ++expected_scores.usage_type1_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      UsageStore::UsageScores actual_scores,
+      document_store->GetUsageScores(document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Update the document.
   ICING_ASSERT_OK_AND_ASSIGN(
@@ -3091,8 +3111,9 @@ TEST_F(DocumentStoreTest, UsageScoresShouldBeCopiedOverToUpdatedDocument) {
   ASSERT_THAT(updated_document_id, Not(Eq(document_id)));
 
   // Usage scores should be the same.
-  EXPECT_THAT(document_store->GetUsageScores(updated_document_id),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores, document_store->GetUsageScores(updated_document_id));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 }
 
 TEST_F(DocumentStoreTest, UsageScoresShouldPersistOnOptimize) {
@@ -3119,8 +3140,10 @@ TEST_F(DocumentStoreTest, UsageScoresShouldPersistOnOptimize) {
 
   UsageStore::UsageScores expected_scores;
   ++expected_scores.usage_type1_count;
-  ASSERT_THAT(document_store->GetUsageScores(document_id2),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      UsageStore::UsageScores actual_scores,
+      document_store->GetUsageScores(document_id2));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 
   // Run optimize
   std::string optimized_dir = document_store_dir_ + "/optimize_test";
@@ -3137,8 +3160,10 @@ TEST_F(DocumentStoreTest, UsageScoresShouldPersistOnOptimize) {
 
   // Usage scores should be the same.
   // The original document_id2 should have become document_id2 - 1.
-  ASSERT_THAT(optimized_document_store->GetUsageScores(document_id2 - 1),
-              IsOkAndHolds(expected_scores));
+  ICING_ASSERT_HAS_VALUE_AND_ASSIGN(
+      actual_scores,
+      optimized_document_store->GetUsageScores(document_id2 - 1));
+  EXPECT_THAT(actual_scores, Eq(expected_scores));
 }
 
 TEST_F(DocumentStoreTest, DetectPartialDataLoss) {
diff --git a/icing/store/usage-store.h b/icing/store/usage-store.h
index fd77df4..3c7a55e 100644
--- a/icing/store/usage-store.h
+++ b/icing/store/usage-store.h
@@ -180,6 +180,8 @@ class UsageStore {
   //   INTERNAL_ERROR on I/O error
   libtextclassifier3::Status Reset();
 
+  int32_t num_elements() const { return usage_score_cache_->num_elements(); }
+
  private:
   explicit UsageStore(std::unique_ptr<FileBackedVector<UsageScores>>
                           document_id_to_scores_mapper,
diff --git a/icing/tokenization/icu/icu-language-segmenter.h b/icing/tokenization/icu/icu-language-segmenter.h
index e22c5d2..1ca70c5 100644
--- a/icing/tokenization/icu/icu-language-segmenter.h
+++ b/icing/tokenization/icu/icu-language-segmenter.h
@@ -101,7 +101,7 @@ class IcuLanguageSegmenter : public LanguageSegmenter {
 
   // The underlying class that does the segmentation, ubrk_close() must be
   // called after using.
-  mutable UBreakIterator* cached_break_iterator_ ICING_LOCKS_EXCLUDED(mutex_);
+  mutable UBreakIterator* cached_break_iterator_ ICING_GUARDED_BY(mutex_);
 
   mutable absl_ports::shared_mutex mutex_;
 };
diff --git a/synced_AOSP_CL_number.txt b/synced_AOSP_CL_number.txt
index 5ff4997..6c9442c 100644
--- a/synced_AOSP_CL_number.txt
+++ b/synced_AOSP_CL_number.txt
@@ -1 +1 @@
-set(synced_AOSP_CL_number=516534290)
+set(synced_AOSP_CL_number=517138860)