Update from https://crrev.com/316786

cc/resources/tile_manager.h

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CC_RESOURCES_TILE_MANAGER_H_
 #define CC_RESOURCES_TILE_MANAGER_H_
 
 #include <deque>
 #include <queue>
 #include <set>
@@ skipping 12 matching lines @@
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_draw_info.h"
 #include "cc/resources/tile_task_runner.h"
 
 namespace base {
 namespace trace_event {
 class ConvertableToTraceFormat;
 class TracedValue;
 }
-
-// TODO(ssid): remove these aliases after the tracing clients are moved to the
-// new trace_event namespace. See crbug.com/451032. ETA: March 2015
-namespace debug {
-using ::base::trace_event::ConvertableToTraceFormat;
-using ::base::trace_event::TracedValue;
 }
-}  // namespace base
 
 namespace cc {
 class PictureLayerImpl;
 class Rasterizer;
 class ResourceProvider;
 
 class CC_EXPORT TileManagerClient {
  public:
   // Called when all tiles marked as required for activation are ready to draw.
   virtual void NotifyReadyToActivate() = 0;
@@ skipping 29 matching lines @@
  protected:
   virtual ~TileManagerClient() {}
 };
 
 struct RasterTaskCompletionStats {
   RasterTaskCompletionStats();
 
   size_t completed_count;
   size_t canceled_count;
 };
-scoped_refptr<base::debug::ConvertableToTraceFormat>
-    RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats);
+scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats);
 
 // This class manages tiles, deciding which should get rasterized and which
 // should no longer have any memory assigned to them. Tile objects are "owned"
 // by layers; they automatically register with the manager when they are
 // created, and unregister from the manager when they are deleted.
 class CC_EXPORT TileManager : public TileTaskRunnerClient,
                               public RefCountedManager<Tile> {
  public:
   enum NamedTaskSet {
     REQUIRED_FOR_ACTIVATION,
@@ skipping 26 matching lines @@
   void UpdateVisibleTiles(const GlobalStateThatImpactsTilePriority& state);
 
   scoped_refptr<Tile> CreateTile(RasterSource* raster_source,
                                  const gfx::Size& desired_texture_size,
                                  const gfx::Rect& content_rect,
                                  float contents_scale,
                                  int layer_id,
                                  int source_frame_number,
                                  int flags);
 
-  scoped_refptr<base::debug::ConvertableToTraceFormat> BasicStateAsValue()
+  scoped_refptr<base::trace_event::ConvertableToTraceFormat> BasicStateAsValue()
       const;
-  void BasicStateAsValueInto(base::debug::TracedValue* dict) const;
+  void BasicStateAsValueInto(base::trace_event::TracedValue* dict) const;
   const MemoryHistory::Entry& memory_stats_from_last_assign() const {
     return memory_stats_from_last_assign_;
   }
 
   void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) {
     for (size_t i = 0; i < tiles.size(); ++i) {
       TileDrawInfo& draw_info = tiles[i]->draw_info();
       draw_info.resource_ = resource_pool_->AcquireResource(
           tiles[i]->desired_texture_size(),
           tile_task_runner_->GetResourceFormat());
@@ skipping 167 matching lines @@
 
   bool did_notify_ready_to_activate_;
   bool did_notify_ready_to_draw_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TILE_MANAGER_H_