Reland of Move ScriptState::GetExecutionContext (Part 5)

third_party/WebKit/Source/modules/indexeddb/IDBObjectStore.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 135 matching lines @@
         IDBDatabase::kTransactionFinishedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(
         kTransactionInactiveError,
         IDBDatabase::kTransactionInactiveErrorMessage);
     return nullptr;
   }
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
-      script_state->GetExecutionContext(), key, exception_state);
+      ExecutionContext::From(script_state), key, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!key_range) {
     exception_state.ThrowDOMException(
         kDataError, IDBDatabase::kNoKeyOrKeyRangeErrorMessage);
     return nullptr;
   }
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
@@ skipping 23 matching lines @@
         IDBDatabase::kTransactionFinishedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(
         kTransactionInactiveError,
         IDBDatabase::kTransactionInactiveErrorMessage);
     return nullptr;
   }
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
-      script_state->GetExecutionContext(), key, exception_state);
+      ExecutionContext::From(script_state), key, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!key_range) {
     exception_state.ThrowDOMException(
         kDataError, IDBDatabase::kNoKeyOrKeyRangeErrorMessage);
     return nullptr;
   }
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
@@ skipping 34 matching lines @@
         IDBDatabase::kTransactionFinishedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(
         kTransactionInactiveError,
         IDBDatabase::kTransactionInactiveErrorMessage);
     return nullptr;
   }
   IDBKeyRange* range = IDBKeyRange::FromScriptValue(
-      script_state->GetExecutionContext(), key_range, exception_state);
+      ExecutionContext::From(script_state), key_range, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
                                            transaction_.Get());
@@ skipping 29 matching lines @@
         IDBDatabase::kTransactionFinishedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(
         kTransactionInactiveError,
         IDBDatabase::kTransactionInactiveErrorMessage);
     return nullptr;
   }
   IDBKeyRange* range = IDBKeyRange::FromScriptValue(
-      script_state->GetExecutionContext(), key_range, exception_state);
+      ExecutionContext::From(script_state), key_range, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
                                            transaction_.Get());
@@ skipping 99 matching lines @@
         kReadOnlyError, IDBDatabase::kTransactionReadOnlyErrorMessage);
     return nullptr;
   }
 
   v8::Isolate* isolate = script_state->GetIsolate();
   DCHECK(isolate->InContext());
   Vector<WebBlobInfo> blob_info;
   SerializedScriptValue::SerializeOptions options;
   options.blob_info = &blob_info;
   options.write_wasm_to_stream =
-      script_state->GetExecutionContext()->IsSecureContext();
+      ExecutionContext::From(script_state)->IsSecureContext();
   RefPtr<SerializedScriptValue> serialized_value =
       SerializedScriptValue::Serialize(isolate, value.V8Value(), options,
                                        exception_state);
   if (exception_state.HadException())
     return nullptr;
 
   // Keys that need to be extracted must be taken from a clone so that
   // side effects (i.e. getters) are not triggered. Construct the
   // clone lazily since the operation may be expensive.
   ScriptValue clone;
@@ skipping 140 matching lines @@
         IDBDatabase::kTransactionInactiveErrorMessage);
     return nullptr;
   }
   if (transaction_->IsReadOnly()) {
     exception_state.ThrowDOMException(
         kReadOnlyError, IDBDatabase::kTransactionReadOnlyErrorMessage);
     return nullptr;
   }
 
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
-      script_state->GetExecutionContext(), key, exception_state);
+      ExecutionContext::From(script_state), key, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!key_range) {
     exception_state.ThrowDOMException(
         kDataError, IDBDatabase::kNoKeyOrKeyRangeErrorMessage);
     return nullptr;
   }
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
@@ skipping 85 matching lines @@
         index_metadata_(std::move(index_metadata)) {
     DCHECK(index_metadata_.Get());
   }
 
   const IDBIndexMetadata& IndexMetadata() const { return *index_metadata_; }
 
   void handleEvent(ExecutionContext* execution_context, Event* event) override {
     if (!script_state_->ContextIsValid())
       return;
 
-    DCHECK_EQ(script_state_->GetExecutionContext(), execution_context);
+    DCHECK_EQ(ExecutionContext::From(script_state_.Get()), execution_context);
     DCHECK_EQ(event->type(), EventTypeNames::success);
     EventTarget* target = event->target();
     IDBRequest* request = static_cast<IDBRequest*>(target);
 
     if (!database_->Backend())  // If database is stopped?
       return;
 
     ScriptState::Scope scope(script_state_.Get());
 
     IDBAny* cursor_any = request->ResultAsAny();
@@ skipping 220 matching lines @@
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(
         kTransactionInactiveError,
         IDBDatabase::kTransactionInactiveErrorMessage);
     return nullptr;
   }
 
   WebIDBCursorDirection direction =
       IDBCursor::StringToDirection(direction_string);
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
-      script_state->GetExecutionContext(), range, exception_state);
+      ExecutionContext::From(script_state), range, exception_state);
   if (exception_state.HadException())
     return nullptr;
 
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
   return openCursor(script_state, key_range, direction, kWebIDBTaskTypeNormal);
@@ skipping 32 matching lines @@
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(
         kTransactionInactiveError,
         IDBDatabase::kTransactionInactiveErrorMessage);
     return nullptr;
   }
 
   WebIDBCursorDirection direction =
       IDBCursor::StringToDirection(direction_string);
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
-      script_state->GetExecutionContext(), range, exception_state);
+      ExecutionContext::From(script_state), range, exception_state);
   if (exception_state.HadException())
     return nullptr;
 
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
@@ skipping 23 matching lines @@
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(
         kTransactionInactiveError,
         IDBDatabase::kTransactionInactiveErrorMessage);
     return nullptr;
   }
 
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
-      script_state->GetExecutionContext(), range, exception_state);
+      ExecutionContext::From(script_state), range, exception_state);
   if (exception_state.HadException())
     return nullptr;
 
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
@@ skipping 102 matching lines @@
     }
   }
   return IDBIndexMetadata::kInvalidId;
 }
 
 WebIDBDatabase* IDBObjectStore::BackendDB() const {
   return transaction_->BackendDB();
 }
 
 }  // namespace blink