// Copyright 2017 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "cobalt/script/mozjs-45/mozjs_tracer.h"

#include "base/containers/hash_tables.h"
#include "cobalt/script/mozjs-45/mozjs_global_environment.h"
#include "cobalt/script/mozjs-45/wrapper_private.h"
#include "third_party/mozjs-45/js/public/Proxy.h"

namespace cobalt {
namespace script {
namespace mozjs {

void MozjsTracer::Trace(Traceable* traceable) {
  if (!traceable) {
    return;
  }

  // Unfortunately, |JSTracer| will only supply us with a |JSRuntime|,
  // rather than a |JSContext|. Fortunately, Cobalt will only create one
  // global environment per runtime, so we can still safely get back to our
  // context, and thus our global environment.
  JSContext* context = nullptr;
  JS_ContextIterator(js_tracer_->runtime(), &context);
  DCHECK(context);
  MozjsGlobalEnvironment* global_environment =
      MozjsGlobalEnvironment::GetFromContext(context);
  DCHECK(global_environment);

  // Clearly, if we have already visited this wrappable during the current
  // tracing session, there is no need to visit it again. We rely on
  // |JS_SetGCCallback| in the |MozjsEngine| to properly manage clearing
  // |visited_wrappables_| in between GC sessions.
  base::hash_set<Traceable*>* visited_traceables =
      global_environment->visited_traceables();
  DCHECK(visited_traceables);
  if (!visited_traceables->insert(traceable).second) {
    return;
  }

  if (!traceable->IsWrappable()) {
    frontier_.push_back(traceable);
    return;
  }

  Wrappable* wrappable = base::polymorphic_downcast<Wrappable*>(traceable);

  // There are now two cases left to handle. Since we cannot create the
  // wrapper while tracing due to internal SpiderMonkey restrictions, we will
  // instead directly call |TraceMembers| here if the wrapper does not exist.
  // In the case where the wrapper already does exist, we will pass the
  // wrapper to |JS_CallObjectTracer|, and rely on SpiderMonkey to begin
  // another |WrapperPrivate::Trace| on that wrapper.
  WrapperFactory* wrapper_factory = global_environment->wrapper_factory();
  if (!wrapper_factory->HasWrapperProxy(wrappable)) {
    frontier_.push_back(wrappable);
  } else {
    JSObject* proxy_object = wrapper_factory->GetWrapperProxy(wrappable);
    JSObject* target = js::GetProxyTargetObject(proxy_object);
    WrapperPrivate* wrapper_private =
        static_cast<WrapperPrivate*>(JS_GetPrivate(target));
    DCHECK(wrapper_private->context_ == context);
    DCHECK(wrapper_private->wrapper_proxy_);
    JS_CallObjectTracer(js_tracer_, &wrapper_private->wrapper_proxy_,
                        "MozjsTracer::Trace");
  }

  DCHECK(JS_ContextIterator(js_tracer_->runtime(), &context) == nullptr);
}

void MozjsTracer::TraceFrom(Traceable* traceable) {
  DCHECK(frontier_.empty());
  frontier_.push_back(traceable);
  DrainFrontier();
}

void MozjsTracer::DrainFrontier() {
  while (!frontier_.empty()) {
    Traceable* back = frontier_.back();
    frontier_.pop_back();
    back->TraceMembers(this);
  }
}

}  // namespace mozjs
}  // namespace script
}  // namespace cobalt