[cleanup] [proxies] Unify style of recently written code

src/key-accumulator.cc

 // Copyright 2013 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/key-accumulator.h"
 
 #include "src/elements.h"
 #include "src/factory.h"
 #include "src/isolate-inl.h"
 #include "src/objects-inl.h"
@@ skipping 216 matching lines @@
   if (filter == ALL_PROPERTIES) {
     // Nothing to do.
     return keys;
   }
   int store_position = 0;
   for (int i = 0; i < keys->length(); ++i) {
     Handle<Name> key(Name::cast(keys->get(i)), isolate);
     if (key->FilterKey(filter)) continue;  // Skip this key.
     if (filter & ONLY_ENUMERABLE) {
       PropertyDescriptor desc;
-      bool found =
+      Maybe<bool> found =
           JSProxy::GetOwnPropertyDescriptor(isolate, owner, key, &desc);
-      if (isolate->has_pending_exception()) return MaybeHandle<FixedArray>();
-      if (!found || !desc.enumerable()) continue;  // Skip this key.
+      MAYBE_RETURN(found, MaybeHandle<FixedArray>());
+      if (!found.FromJust() || !desc.enumerable()) continue;  // Skip this key.
     }
     // Keep this key.
     if (store_position != i) {
       keys->set(store_position, *key);
     }
     store_position++;
   }
   if (store_position == 0) return isolate->factory()->empty_fixed_array();
   keys->Shrink(store_position);
   return keys;
 }
 
 
-// Returns "false" in case of exception, "true" on success.
-bool KeyAccumulator::AddKeysFromProxy(Handle<JSProxy> proxy,
-                                      Handle<FixedArray> keys) {
+// Returns "nothing" in case of exception, "true" on success.
+Maybe<bool> KeyAccumulator::AddKeysFromProxy(Handle<JSProxy> proxy,
+                                             Handle<FixedArray> keys) {
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, keys, FilterProxyKeys(isolate_, proxy, keys, filter_), false);
+      isolate_, keys, FilterProxyKeys(isolate_, proxy, keys, filter_),
+      Nothing<bool>());
   // Proxies define a complete list of keys with no distinction of
   // elements and properties, which breaks the normal assumption for the
   // KeyAccumulator.
   AddKeys(keys, PROXY_MAGIC);
   // Invert the current length to indicate a present proxy, so we can ignore
   // element keys for this level. Otherwise we would not fully respect the order
   // given by the proxy.
   level_string_length_ = -level_string_length_;
-  return true;
+  return Just(true);
 }
 
 
 void KeyAccumulator::AddElementKeysFromInterceptor(
     Handle<JSObject> array_like) {
   AddKeys(array_like, CONVERT_TO_ARRAY_INDEX);
   // The interceptor might introduce duplicates for the current level, since
   // these keys get added after the objects's normal element keys.
   SortCurrentElementsListRemoveDuplicates();
 }
@@ skipping 27 matching lines @@
     level_lengths_.push_back(level_symbol_length_);
   }
   elements_.push_back(new std::vector<uint32_t>());
   level_string_length_ = 0;
   level_symbol_length_ = 0;
 }
 
 
 }  // namespace internal
 }  // namespace v8