1// Copyright 2012 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_LAYERS_HEADS_UP_DISPLAY_LAYER_IMPL_H_
6#define CC_LAYERS_HEADS_UP_DISPLAY_LAYER_IMPL_H_
7
8#include <string>
9#include <vector>
10
11#include "base/memory/scoped_ptr.h"
12#include "base/time/time.h"
13#include "cc/base/cc_export.h"
14#include "cc/debug/debug_rect_history.h"
15#include "cc/layers/layer_impl.h"
16#include "cc/resources/memory_history.h"
17#include "cc/resources/scoped_resource.h"
18
19class SkCanvas;
20class SkPaint;
21class SkTypeface;
22struct SkRect;
23
24namespace cc {
25
26class FrameRateCounter;
27class PaintTimeCounter;
28
29class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
30 public:
31  static scoped_ptr<HeadsUpDisplayLayerImpl> Create(LayerTreeImpl* tree_impl,
32                                                    int id) {
33    return make_scoped_ptr(new HeadsUpDisplayLayerImpl(tree_impl, id));
34  }
35  virtual ~HeadsUpDisplayLayerImpl();
36
37  virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
38      OVERRIDE;
39
40  virtual bool WillDraw(DrawMode draw_mode,
41                        ResourceProvider* resource_provider) OVERRIDE;
42  virtual void AppendQuads(RenderPass* render_pass,
43                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
44                           AppendQuadsData* append_quads_data) OVERRIDE;
45  void UpdateHudTexture(DrawMode draw_mode,
46                        ResourceProvider* resource_provider);
47
48  virtual void ReleaseResources() OVERRIDE;
49
50  bool IsAnimatingHUDContents() const { return fade_step_ > 0; }
51
52 private:
53  class Graph {
54   public:
55    Graph(double indicator_value, double start_upper_bound);
56
57    // Eases the upper bound, which limits what is currently visible in the
58    // graph, so that the graph always scales to either it's max or
59    // default_upper_bound.
60    double UpdateUpperBound();
61
62    double value;
63    double min;
64    double max;
65
66    double current_upper_bound;
67    const double default_upper_bound;
68    const double indicator;
69  };
70
71  HeadsUpDisplayLayerImpl(LayerTreeImpl* tree_impl, int id);
72
73  virtual const char* LayerTypeAsString() const OVERRIDE;
74
75  virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
76
77  void UpdateHudContents();
78  void DrawHudContents(SkCanvas* canvas);
79
80  void DrawText(SkCanvas* canvas,
81                SkPaint* paint,
82                const std::string& text,
83                SkPaint::Align align,
84                int size,
85                int x,
86                int y) const;
87  void DrawText(SkCanvas* canvas,
88                SkPaint* paint,
89                const std::string& text,
90                SkPaint::Align align,
91                int size,
92                const SkPoint& pos) const;
93  void DrawGraphBackground(SkCanvas* canvas,
94                           SkPaint* paint,
95                           const SkRect& bounds) const;
96  void DrawGraphLines(SkCanvas* canvas,
97                      SkPaint* paint,
98                      const SkRect& bounds,
99                      const Graph& graph) const;
100
101  SkRect DrawFPSDisplay(SkCanvas* canvas,
102                        const FrameRateCounter* fps_counter,
103                        int right,
104                        int top) const;
105  SkRect DrawMemoryDisplay(SkCanvas* canvas,
106                           int top,
107                           int right,
108                           int width) const;
109  SkRect DrawPaintTimeDisplay(SkCanvas* canvas,
110                              const PaintTimeCounter* paint_time_counter,
111                              int top,
112                              int right) const;
113  void DrawDebugRect(SkCanvas* canvas,
114                     SkPaint* paint,
115                     const DebugRect& rect,
116                     SkColor stroke_color,
117                     SkColor fill_color,
118                     float stroke_width,
119                     const std::string& label_text) const;
120  void DrawDebugRects(SkCanvas* canvas, DebugRectHistory* debug_rect_history);
121
122  void AcquireResource(ResourceProvider* resource_provider);
123  void ReleaseUnmatchedSizeResources(ResourceProvider* resource_provider);
124
125  ScopedPtrVector<ScopedResource> resources_;
126  scoped_ptr<SkCanvas> hud_canvas_;
127
128  skia::RefPtr<SkTypeface> typeface_;
129
130  Graph fps_graph_;
131  Graph paint_time_graph_;
132  MemoryHistory::Entry memory_entry_;
133  int fade_step_;
134  std::vector<DebugRect> paint_rects_;
135
136  base::TimeTicks time_of_last_graph_update_;
137
138  DISALLOW_COPY_AND_ASSIGN(HeadsUpDisplayLayerImpl);
139};
140
141}  // namespace cc
142
143#endif  // CC_LAYERS_HEADS_UP_DISPLAY_LAYER_IMPL_H_
144