tree_synchronizer.cc | Explore in Territory

// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "cc/trees/tree_synchronizer.h"

#include <stddef.h>

#include <memory>
#include <set>
#include <utility>

#include "base/check_op.h"
#include "base/containers/contains.h"
#include "base/containers/flat_set.h"
#include "base/debug/crash_logging.h"
#include "base/debug/dump_without_crashing.h"
#include "base/trace_event/trace_event.h"
#include "cc/layers/layer.h"
#include "cc/layers/layer_collections.h"
#include "cc/layers/layer_impl.h"
#include "cc/trees/layer_tree_host.h"
#include "cc/trees/layer_tree_impl.h"

namespace cc {
namespace {
#if DCHECK_IS_ON()
static void AssertValidPropertyTreeIndices(
    const Layer* layer,
    const PropertyTrees& property_trees) { … }

static void AssertValidPropertyTreeIndices(const LayerImpl* layer,
                                           const PropertyTrees&) { … }

static bool LayerHasValidPropertyTreeIndices(const LayerImpl* layer) { … }

static bool LayerWillPushProperties(const LayerTreeImpl* tree,
                                    const LayerImpl* layer) { … }
#endif

template <typename LayerType>
std::unique_ptr<LayerImpl> ReuseOrCreateLayerImpl(OwnedLayerImplMap* old_layers,
                                                  const LayerType* layer,
                                                  LayerTreeImpl* tree_impl) { … }

void PushLayerList(OwnedLayerImplMap* old_layers,
                   const CommitState& commit_state,
                   const ThreadUnsafeCommitState& unsafe_state,
                   LayerTreeImpl* tree_impl) { … }

void PushLayerList(OwnedLayerImplMap* old_layers,
                   LayerTreeImpl* host,
                   LayerTreeImpl* tree_impl,
                   const PropertyTrees& property_trees) { … }

void SynchronizeTreesInternal(const CommitState& commit_state,
                              const ThreadUnsafeCommitState& unsafe_state,
                              LayerTreeImpl* tree_impl) { … }

void SynchronizeTreesInternal(LayerTreeImpl* source_tree,
                              LayerTreeImpl* tree_impl,
                              const PropertyTrees& property_trees) { … }

}  // namespace

void TreeSynchronizer::SynchronizeTrees(
    const CommitState& commit_state,
    const ThreadUnsafeCommitState& unsafe_state,
    LayerTreeImpl* tree_impl) { … }

void TreeSynchronizer::SynchronizeTrees(LayerTreeImpl* pending_tree,
                                        LayerTreeImpl* active_tree) { … }

template <typename Iterator>
static void PushLayerPropertiesInternal(Iterator source_layers_begin,
                                        Iterator source_layers_end,
                                        LayerTreeImpl* target_impl_tree) { … }

void TreeSynchronizer::PushLayerProperties(LayerTreeImpl* pending_tree,
                                           LayerTreeImpl* active_tree) { … }

void TreeSynchronizer::PushLayerProperties(
    const CommitState& commit_state,
    const ThreadUnsafeCommitState& unsafe_state,
    LayerTreeImpl* impl_tree) { … }

}  // namespace cc
chromium/cc/trees/tree_synchronizer.cc
