Update Icing from upstream.

Change-Id: Iff50aebffb83529b0454e7c3a6dc6864e7a85f4a

2 files changed, 16 insertions, 13 deletions

diff --git a/icing/index/lite/lite-index.cc b/icing/index/lite/lite-index.cc
index ea4bcaf..e0379b8 100644
--- a/icing/index/lite/lite-index.cc
+++ b/icing/index/lite/lite-index.cc
@@ -365,7 +365,7 @@ int LiteIndex::AppendHits(uint32_t term_id, SectionIdMask section_id_mask,
       last_document_id = document_id;
     }
     if (hits_out != nullptr) {
-      hits_out->back().UpdateSection(hit.section_id(), hit.score());
+      hits_out->back().UpdateSection(hit.section_id(), hit.term_frequency());
     }
   }
   return count;
@@ -448,7 +448,7 @@ uint32_t LiteIndex::Seek(uint32_t term_id) {
   // Binary search for our term_id.  Make sure we get the first
   // element.  Using kBeginSortValue ensures this for the hit value.
   TermIdHitPair term_id_hit_pair(
-      term_id, Hit(Hit::kMaxDocumentIdSortValue, Hit::kDefaultHitScore));
+      term_id, Hit(Hit::kMaxDocumentIdSortValue, Hit::kDefaultTermFrequency));
 
   const TermIdHitPair::Value* array =
       hit_buffer_.array_cast<TermIdHitPair::Value>();
diff --git a/icing/index/lite/term-id-hit-pair.h b/icing/index/lite/term-id-hit-pair.h
index 191f766..61ec502 100644
--- a/icing/index/lite/term-id-hit-pair.h
+++ b/icing/index/lite/term-id-hit-pair.h
@@ -29,39 +29,42 @@ namespace lib {
 
 class TermIdHitPair {
  public:
-  // Layout bits: 24 termid + 32 hit value + 8 hit score.
+  // Layout bits: 24 termid + 32 hit value + 8 hit term frequency.
   using Value = uint64_t;
 
   static constexpr int kTermIdBits = 24;
   static constexpr int kHitValueBits = sizeof(Hit::Value) * 8;
-  static constexpr int kHitScoreBits = sizeof(Hit::Score) * 8;
+  static constexpr int kHitTermFrequencyBits = sizeof(Hit::TermFrequency) * 8;
 
   static const Value kInvalidValue;
 
   explicit TermIdHitPair(Value v = kInvalidValue) : value_(v) {}
 
   TermIdHitPair(uint32_t term_id, const Hit& hit) {
-    static_assert(
-        kTermIdBits + kHitValueBits + kHitScoreBits <= sizeof(Value) * 8,
-        "TermIdHitPairTooBig");
+    static_assert(kTermIdBits + kHitValueBits + kHitTermFrequencyBits <=
+                      sizeof(Value) * 8,
+                  "TermIdHitPairTooBig");
 
     value_ = 0;
     // Term id goes into the most significant bits because it takes
     // precedent in sorts.
-    bit_util::BitfieldSet(term_id, kHitValueBits + kHitScoreBits, kTermIdBits,
+    bit_util::BitfieldSet(term_id, kHitValueBits + kHitTermFrequencyBits,
+                          kTermIdBits, &value_);
+    bit_util::BitfieldSet(hit.value(), kHitTermFrequencyBits, kHitValueBits,
+                          &value_);
+    bit_util::BitfieldSet(hit.term_frequency(), 0, kHitTermFrequencyBits,
                           &value_);
-    bit_util::BitfieldSet(hit.value(), kHitScoreBits, kHitValueBits, &value_);
-    bit_util::BitfieldSet(hit.score(), 0, kHitScoreBits, &value_);
   }
 
   uint32_t term_id() const {
-    return bit_util::BitfieldGet(value_, kHitValueBits + kHitScoreBits,
+    return bit_util::BitfieldGet(value_, kHitValueBits + kHitTermFrequencyBits,
                                  kTermIdBits);
   }
 
   Hit hit() const {
-    return Hit(bit_util::BitfieldGet(value_, kHitScoreBits, kHitValueBits),
-               bit_util::BitfieldGet(value_, 0, kHitScoreBits));
+    return Hit(
+        bit_util::BitfieldGet(value_, kHitTermFrequencyBits, kHitValueBits),
+        bit_util::BitfieldGet(value_, 0, kHitTermFrequencyBits));
   }
 
   Value value() const { return value_; }