Home | History | Annotate | Download | only in debug 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CC_DEBUG_FRAME_VIEWER_INSTRUMENTATION_H_
      6 #define CC_DEBUG_FRAME_VIEWER_INSTRUMENTATION_H_
      7 
      8 #include "base/debug/trace_event.h"
      9 #include "cc/resources/tile.h"
     10 
     11 namespace cc {
     12 namespace frame_viewer_instrumentation {
     13 namespace internal {
     14 
     15 const char kCategory[] = "cc";
     16 const char kTileData[] = "tileData";
     17 const char kLayerId[] = "layerId";
     18 const char kTileId[] = "tileId";
     19 const char kTileResolution[] = "tileResolution";
     20 const char kSourceFrameNumber[] = "sourceFrameNumber";
     21 const char kRasterMode[] = "rasterMode";
     22 
     23 const char kAnalyzeTask[] = "AnalyzeTask";
     24 const char kRasterTask[] = "RasterTask";
     25 
     26 scoped_ptr<base::Value> TileDataAsValue(const void* tile_id,
     27                                         TileResolution tile_resolution,
     28                                         int source_frame_number,
     29                                         int layer_id) {
     30   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue);
     31   res->Set(internal::kTileId, TracedValue::CreateIDRef(tile_id).release());
     32   res->Set(internal::kTileResolution,
     33            TileResolutionAsValue(tile_resolution).release());
     34   res->SetInteger(internal::kSourceFrameNumber, source_frame_number);
     35   res->SetInteger(internal::kLayerId, layer_id);
     36   return res.PassAs<base::Value>();
     37 }
     38 
     39 }  // namespace internal
     40 
     41 class ScopedAnalyzeTask {
     42  public:
     43   ScopedAnalyzeTask(const void* tile_id,
     44                     TileResolution tile_resolution,
     45                     int source_frame_number,
     46                     int layer_id) {
     47     TRACE_EVENT_BEGIN1(
     48         internal::kCategory,
     49         internal::kAnalyzeTask,
     50         internal::kTileData,
     51         TracedValue::FromValue(internal::TileDataAsValue(tile_id,
     52                                                          tile_resolution,
     53                                                          source_frame_number,
     54                                                          layer_id).release()));
     55   }
     56   ~ScopedAnalyzeTask() {
     57     TRACE_EVENT_END0(internal::kCategory, internal::kAnalyzeTask);
     58   }
     59 
     60  private:
     61   DISALLOW_COPY_AND_ASSIGN(ScopedAnalyzeTask);
     62 };
     63 
     64 class ScopedRasterTask {
     65  public:
     66   ScopedRasterTask(const void* tile_id,
     67                    TileResolution tile_resolution,
     68                    int source_frame_number,
     69                    int layer_id,
     70                    RasterMode raster_mode) {
     71     TRACE_EVENT_BEGIN2(
     72         internal::kCategory,
     73         internal::kRasterTask,
     74         internal::kTileData,
     75         TracedValue::FromValue(internal::TileDataAsValue(tile_id,
     76                                                          tile_resolution,
     77                                                          source_frame_number,
     78                                                          layer_id).release()),
     79         internal::kRasterMode,
     80         TracedValue::FromValue(RasterModeAsValue(raster_mode).release()));
     81   }
     82   ~ScopedRasterTask() {
     83     TRACE_EVENT_END0(internal::kCategory, internal::kRasterTask);
     84   }
     85 
     86  private:
     87   DISALLOW_COPY_AND_ASSIGN(ScopedRasterTask);
     88 };
     89 
     90 }  // namespace frame_viewer_instrumentation
     91 }  // namespace cc
     92 
     93 #endif  // CC_DEBUG_FRAME_VIEWER_INSTRUMENTATION_H_
     94