Address compilation warnings for android build.

src/uri.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/uri.h"
 
 #include "src/char-predicates-inl.h"
 #include "src/handles.h"
 #include "src/isolate-inl.h"
 #include "src/list.h"
@@ skipping 74 matching lines @@
   } else {
     buffer->Add(decoded);
   }
 }
 
 bool IntoTwoByte(int index, bool is_uri, int uri_length,
                  String::FlatContent* uri_content, List<uc16>* buffer) {
   for (int k = index; k < uri_length; k++) {
     uc16 code = uri_content->Get(k);
     if (code == '%') {
-      uc16 decoded;
+      int two_digits;
       if (k + 2 >= uri_length ||
-          (decoded = TwoDigitHex(uri_content->Get(k + 1),
-                                 uri_content->Get(k + 2))) < 0) {
+          (two_digits = TwoDigitHex(uri_content->Get(k + 1),
+                                    uri_content->Get(k + 2))) < 0) {
         return false;
       }
       k += 2;
+      uc16 decoded = static_cast<uc16>(two_digits);
       if (decoded > unibrow::Utf8::kMaxOneByteChar) {
         uint8_t octets[unibrow::Utf8::kMaxEncodedSize];
         octets[0] = decoded;
 
         int number_of_continuation_bytes = 0;
         while ((decoded << ++number_of_continuation_bytes) & 0x80) {
           if (number_of_continuation_bytes > 3 || k + 3 >= uri_length) {
             return false;
           }
-
-          uc16 continuation_byte;
-
           if (uri_content->Get(++k) != '%' ||
-              (continuation_byte = TwoDigitHex(uri_content->Get(k + 1),
-                                               uri_content->Get(k + 2))) < 0) {
+              (two_digits = TwoDigitHex(uri_content->Get(k + 1),
+                                        uri_content->Get(k + 2))) < 0) {
             return false;
           }
           k += 2;
+          uc16 continuation_byte = static_cast<uc16>(two_digits);
           octets[number_of_continuation_bytes] = continuation_byte;
         }
 
         if (!DecodeOctets(octets, number_of_continuation_bytes, buffer)) {
           return false;
         }
       } else {
         AddToBuffer(decoded, uri_content, k - 2, is_uri, buffer);
       }
     } else {
       buffer->Add(code);
     }
   }
   return true;
 }
 
 bool IntoOneAndTwoByte(Handle<String> uri, bool is_uri,
                        List<uint8_t>* one_byte_buffer,
                        List<uc16>* two_byte_buffer) {
   DisallowHeapAllocation no_gc;
   String::FlatContent uri_content = uri->GetFlatContent();
 
   int uri_length = uri->length();
   for (int k = 0; k < uri_length; k++) {
     uc16 code = uri_content.Get(k);
     if (code == '%') {
-      uc16 decoded;
+      int two_digits;
       if (k + 2 >= uri_length ||
-          (decoded = TwoDigitHex(uri_content.Get(k + 1),
-                                 uri_content.Get(k + 2))) < 0) {
+          (two_digits = TwoDigitHex(uri_content.Get(k + 1),
+                                    uri_content.Get(k + 2))) < 0) {
         return false;
       }
 
+      uc16 decoded = static_cast<uc16>(two_digits);
       if (decoded > unibrow::Utf8::kMaxOneByteChar) {
         return IntoTwoByte(k, is_uri, uri_length, &uri_content,
                            two_byte_buffer);
       }
 
       AddToBuffer(decoded, &uri_content, k, is_uri, one_byte_buffer);
       k += 2;
     } else {
       if (code > unibrow::Utf8::kMaxOneByteChar) {
         return IntoTwoByte(k, is_uri, uri_length, &uri_content,
@@ skipping 333 matching lines @@
 MaybeHandle<String> Uri::Unescape(Isolate* isolate, Handle<String> string) {
   Handle<String> result;
   string = String::Flatten(string);
   return string->IsOneByteRepresentationUnderneath()
              ? UnescapePrivate<uint8_t>(isolate, string)
              : UnescapePrivate<uc16>(isolate, string);
 }
 
 }  // namespace internal
 }  // namespace v8