cc/tiles/tile_priority.cc

   1 // Copyright 2012 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/tiles/tile_priority.h"
   6
   7 #include "base/numerics/safe_conversions.h"
   8 #include "base/trace_event/traced_value.h"
   9 #include "base/values.h"
  10 #include "cc/base/math_util.h"
  11
  12 namespace cc {
  13
  14 std::string TileResolutionToString(TileResolution resolution) {
  15   switch (resolution) {
  16   case LOW_RESOLUTION:
  17     return "LOW_RESOLUTION";
  18   case HIGH_RESOLUTION:
  19     return "HIGH_RESOLUTION";
  20   case NON_IDEAL_RESOLUTION:
  21     return "NON_IDEAL_RESOLUTION";
  22   }
  23   DCHECK(false) << "Unrecognized TileResolution value " << resolution;
  24   return "<unknown TileResolution value>";
  25 }
  26
  27 std::string TilePriorityBinToString(TilePriority::PriorityBin bin) {
  28   switch (bin) {
  29     case TilePriority::NOW:
  30       return "NOW";
  31     case TilePriority::SOON:
  32       return "SOON";
  33     case TilePriority::EVENTUALLY:
  34       return "EVENTUALLY";
  35   }
  36   DCHECK(false) << "Unrecognized TilePriority::PriorityBin value " << bin;
  37   return "<unknown TilePriority::PriorityBin value>";
  38 }
  39
  40 void TilePriority::AsValueInto(base::trace_event::TracedValue* state) const {
  41   state->SetString("resolution", TileResolutionToString(resolution));
  42   state->SetString("priority_bin", TilePriorityBinToString(priority_bin));
  43   state->SetDouble("distance_to_visible",
  44                    MathUtil::AsDoubleSafely(distance_to_visible));
  45 }
  46
  47 std::string TileMemoryLimitPolicyToString(TileMemoryLimitPolicy policy) {
  48   switch (policy) {
  49   case ALLOW_NOTHING:
  50     return "ALLOW_NOTHING";
  51   case ALLOW_ABSOLUTE_MINIMUM:
  52     return "ALLOW_ABSOLUTE_MINIMUM";
  53   case ALLOW_PREPAINT_ONLY:
  54     return "ALLOW_PREPAINT_ONLY";
  55   case ALLOW_ANYTHING:
  56     return "ALLOW_ANYTHING";
  57   default:
  58       DCHECK(false) << "Unrecognized policy value";
  59       return "<unknown>";
  60   }
  61 }
  62
  63 bool IsTileMemoryLimitPolicyMoreRestictive(TileMemoryLimitPolicy policy1,
  64                                            TileMemoryLimitPolicy policy2) {
  65   static_assert(
  66       ALLOW_NOTHING < ALLOW_ABSOLUTE_MINIMUM &&
  67           ALLOW_ABSOLUTE_MINIMUM < ALLOW_PREPAINT_ONLY &&
  68           ALLOW_PREPAINT_ONLY < ALLOW_ANYTHING,
  69       "TileMemoryLimitPolicy must be ordered from most restrictive to least "
  70       "restrictive");
  71   return policy1 < policy2;
  72 }
  73
  74 std::string TreePriorityToString(TreePriority prio) {
  75   switch (prio) {
  76   case SAME_PRIORITY_FOR_BOTH_TREES:
  77     return "SAME_PRIORITY_FOR_BOTH_TREES";
  78   case SMOOTHNESS_TAKES_PRIORITY:
  79     return "SMOOTHNESS_TAKES_PRIORITY";
  80   case NEW_CONTENT_TAKES_PRIORITY:
  81     return "NEW_CONTENT_TAKES_PRIORITY";
  82   default:
  83     DCHECK(false) << "Unrecognized priority value " << prio;
  84     return "<unknown>";
  85   }
  86 }
  87
  88 perfetto::protos::pbzero::ChromeCompositorStateMachine::MinorState::TreePriority
  89 TreePriorityToProtozeroEnum(TreePriority priority) {
  90   using pbzeroMinorState =
  91       perfetto::protos::pbzero::ChromeCompositorStateMachine::MinorState;
  92   switch (priority) {
  93     case TreePriority::SAME_PRIORITY_FOR_BOTH_TREES:
  94       return pbzeroMinorState::TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES;
  95     case TreePriority::SMOOTHNESS_TAKES_PRIORITY:
  96       return pbzeroMinorState::TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY;
  97     case TreePriority::NEW_CONTENT_TAKES_PRIORITY:
  98       return pbzeroMinorState::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
  99   }
 100   return pbzeroMinorState::TREE_PRIORITY_UNSPECIFIED;
 101 }
 102
 103 void GlobalStateThatImpactsTilePriority::AsValueInto(
 104     base::trace_event::TracedValue* state) const {
 105   state->SetString("memory_limit_policy",
 106                    TileMemoryLimitPolicyToString(memory_limit_policy));
 107   state->SetInteger("soft_memory_limit_in_bytes",
 108                     base::saturated_cast<int>(soft_memory_limit_in_bytes));
 109   state->SetInteger("hard_memory_limit_in_bytes",
 110                     base::saturated_cast<int>(hard_memory_limit_in_bytes));
 111   state->SetInteger("num_resources_limit",
 112                     base::saturated_cast<int>(num_resources_limit));
 113   state->SetString("tree_priority", TreePriorityToString(tree_priority));
 114 }
 115
 116 }  // namespace cc