cc: Remove use of "internal" namespace for TaskGraph.

BUG=
TBR=vmpstr@chromium.org

Review URL: https://codereview.chromium.org/235963006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@263555 0039d316-1c4b-4281-b951-d872f2087c98

26 files changed, 296 insertions, 355 deletions

diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index b764535..48d7c34 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -28,7 +28,7 @@ base::TimeTicks Now() {
              : base::TimeTicks::HighResNow();
 }
 
-class BenchmarkRasterTask : public internal::Task {
+class BenchmarkRasterTask : public Task {
  public:
   BenchmarkRasterTask(PicturePileImpl* picture_pile,
                       const gfx::Rect& content_rect,
@@ -41,7 +41,7 @@ class BenchmarkRasterTask : public internal::Task {
         is_solid_color_(false),
         best_time_(base::TimeDelta::Max()) {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     PicturePileImpl* picture_pile = picture_pile_->GetCloneForDrawingOnThread(
         RasterWorkerPool::GetPictureCloneIndexForCurrentThread());
@@ -142,8 +142,7 @@ void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
     return;
   }
 
-  internal::TaskGraphRunner* task_graph_runner =
-      RasterWorkerPool::GetTaskGraphRunner();
+  TaskGraphRunner* task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
   DCHECK(task_graph_runner);
 
   if (!task_namespace_.IsValid())
@@ -169,17 +168,17 @@ void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
                                 contents_scale,
                                 rasterize_repeat_count_));
 
-    internal::TaskGraph graph;
+    TaskGraph graph;
 
-    graph.nodes.push_back(internal::TaskGraph::Node(
-        benchmark_raster_task,
-        RasterWorkerPool::kBenchmarkRasterTaskPriority,
-        0u));
+    graph.nodes.push_back(
+        TaskGraph::Node(benchmark_raster_task,
+                        RasterWorkerPool::kBenchmarkRasterTaskPriority,
+                        0u));
 
     task_graph_runner->ScheduleTasks(task_namespace_, &graph);
     task_graph_runner->WaitForTasksToFinishRunning(task_namespace_);
 
-    internal::Task::Vector completed_tasks;
+    Task::Vector completed_tasks;
     task_graph_runner->CollectCompletedTasks(task_namespace_, &completed_tasks);
     DCHECK_EQ(1u, completed_tasks.size());
     DCHECK_EQ(completed_tasks[0], benchmark_raster_task);
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.h b/cc/debug/rasterize_and_record_benchmark_impl.h
index 985df7b..cceef05 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.h
+++ b/cc/debug/rasterize_and_record_benchmark_impl.h
@@ -49,7 +49,7 @@ class RasterizeAndRecordBenchmarkImpl : public MicroBenchmarkImpl {
 
   RasterizeResults rasterize_results_;
   int rasterize_repeat_count_;
-  internal::NamespaceToken task_namespace_;
+  NamespaceToken task_namespace_;
 };
 
 }  // namespace cc
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 43a0412..8960c55 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -421,10 +421,8 @@ bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
   return BindFramebufferToTexture(frame, texture, render_pass->output_rect);
 }
 
-void DirectRenderer::RunOnDemandRasterTask(
-    internal::Task* on_demand_raster_task) {
-  internal::TaskGraphRunner* task_graph_runner =
-      RasterWorkerPool::GetTaskGraphRunner();
+void DirectRenderer::RunOnDemandRasterTask(Task* on_demand_raster_task) {
+  TaskGraphRunner* task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
   DCHECK(task_graph_runner);
 
   // Make sure we have a unique task namespace token.
@@ -432,18 +430,18 @@ void DirectRenderer::RunOnDemandRasterTask(
     on_demand_task_namespace_ = task_graph_runner->GetNamespaceToken();
 
   // Construct a task graph that contains this single raster task.
-  internal::TaskGraph graph;
+  TaskGraph graph;
   graph.nodes.push_back(
-      internal::TaskGraph::Node(on_demand_raster_task,
-                                RasterWorkerPool::kOnDemandRasterTaskPriority,
-                                0u));
+      TaskGraph::Node(on_demand_raster_task,
+                      RasterWorkerPool::kOnDemandRasterTaskPriority,
+                      0u));
 
   // Schedule task and wait for task graph runner to finish running it.
   task_graph_runner->ScheduleTasks(on_demand_task_namespace_, &graph);
   task_graph_runner->WaitForTasksToFinishRunning(on_demand_task_namespace_);
 
   // Collect task now that it has finished running.
-  internal::Task::Vector completed_tasks;
+  Task::Vector completed_tasks;
   task_graph_runner->CollectCompletedTasks(on_demand_task_namespace_,
                                            &completed_tasks);
   DCHECK_EQ(1u, completed_tasks.size());
diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h
index a1eacad..3fbae4a 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -97,7 +97,7 @@ class CC_EXPORT DirectRenderer : public Renderer {
   void DrawRenderPass(DrawingFrame* frame, const RenderPass* render_pass);
   bool UseRenderPass(DrawingFrame* frame, const RenderPass* render_pass);
 
-  void RunOnDemandRasterTask(internal::Task* on_demand_raster_task);
+  void RunOnDemandRasterTask(Task* on_demand_raster_task);
 
   virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) = 0;
   virtual bool BindFramebufferToTexture(DrawingFrame* frame,
@@ -140,7 +140,7 @@ class CC_EXPORT DirectRenderer : public Renderer {
  private:
   gfx::Vector2d enlarge_pass_texture_amount_;
 
-  internal::NamespaceToken on_demand_task_namespace_;
+  NamespaceToken on_demand_task_namespace_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectRenderer);
 };
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index e05a20d..51c83dd 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -79,7 +79,7 @@ class SimpleSwapFence : public ResourceProvider::Fence {
   bool has_passed_;
 };
 
-class OnDemandRasterTaskImpl : public internal::Task {
+class OnDemandRasterTaskImpl : public Task {
  public:
   OnDemandRasterTaskImpl(PicturePileImpl* picture_pile,
                          SkBitmap* bitmap,
@@ -93,7 +93,7 @@ class OnDemandRasterTaskImpl : public internal::Task {
     DCHECK(bitmap_);
   }
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     TRACE_EVENT0("cc", "OnDemandRasterTaskImpl::RunOnWorkerThread");
     SkCanvas canvas(*bitmap_);
@@ -1764,7 +1764,7 @@ void GLRenderer::DrawPictureQuad(const DrawingFrame* frame,
   }
 
   // Create and run on-demand raster task for tile.
-  scoped_refptr<internal::Task> on_demand_raster_task(
+  scoped_refptr<Task> on_demand_raster_task(
       new OnDemandRasterTaskImpl(quad->picture_pile,
                                  &on_demand_tile_raster_bitmap_,
                                  quad->content_rect,
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 86f447e..fb24e44 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -37,7 +37,7 @@ namespace cc {
 
 namespace {
 
-class OnDemandRasterTaskImpl : public internal::Task {
+class OnDemandRasterTaskImpl : public Task {
  public:
   OnDemandRasterTaskImpl(PicturePileImpl* picture_pile,
                          SkCanvas* canvas,
@@ -51,7 +51,7 @@ class OnDemandRasterTaskImpl : public internal::Task {
     DCHECK(canvas_);
   }
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     TRACE_EVENT0("cc", "OnDemandRasterTaskImpl::RunOnWorkerThread");
 
@@ -391,7 +391,7 @@ void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
                "SoftwareRenderer::DrawPictureQuad");
 
   // Create and run on-demand raster task for tile.
-  scoped_refptr<internal::Task> on_demand_raster_task(
+  scoped_refptr<Task> on_demand_raster_task(
       new OnDemandRasterTaskImpl(quad->picture_pile,
                                  current_canvas_,
                                  quad->content_rect,
diff --git a/cc/resources/direct_raster_worker_pool.cc b/cc/resources/direct_raster_worker_pool.cc
index 0be89c1..bf7d7a2 100644
--- a/cc/resources/direct_raster_worker_pool.cc
+++ b/cc/resources/direct_raster_worker_pool.cc
@@ -60,7 +60,7 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  scoped_refptr<internal::RasterizerTask>
+  scoped_refptr<RasterizerTask>
       new_raster_required_for_activation_finished_task(
           CreateRasterRequiredForActivationFinishedTask(
               queue->required_for_activation_count,
@@ -68,7 +68,7 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
               base::Bind(&DirectRasterWorkerPool::
                              OnRasterRequiredForActivationFinished,
                          raster_finished_weak_ptr_factory_.GetWeakPtr())));
-  scoped_refptr<internal::RasterizerTask> new_raster_finished_task(
+  scoped_refptr<RasterizerTask> new_raster_finished_task(
       CreateRasterFinishedTask(
           task_runner_.get(),
           base::Bind(&DirectRasterWorkerPool::OnRasterFinished,
@@ -83,7 +83,7 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
              raster_tasks_.items.begin();
          it != raster_tasks_.items.end();
          ++it) {
-      internal::RasterTask* task = it->task;
+      RasterTask* task = it->task;
 
       if (std::find_if(queue->items.begin(),
                        queue->items.end(),
@@ -105,24 +105,21 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
 void DirectRasterWorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks");
 
-  for (internal::RasterizerTask::Vector::const_iterator it =
-           completed_tasks_.begin();
+  for (RasterizerTask::Vector::const_iterator it = completed_tasks_.begin();
        it != completed_tasks_.end();
        ++it) {
-    internal::RasterizerTask* task = it->get();
+    RasterizerTask* task = it->get();
 
     task->RunReplyOnOriginThread();
   }
   completed_tasks_.clear();
 }
 
-SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(
-    internal::RasterTask* task) {
+SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) {
   return resource_provider_->MapDirectRasterBuffer(task->resource()->id());
 }
 
-void DirectRasterWorkerPool::ReleaseCanvasForRaster(
-    internal::RasterTask* task) {
+void DirectRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) {
   resource_provider_->UnmapDirectRasterBuffer(task->resource()->id());
 }
 
@@ -178,15 +175,15 @@ void DirectRasterWorkerPool::RunTasksOnOriginThread() {
              raster_tasks_.items.begin();
          it != raster_tasks_.items.end();
          ++it) {
-      internal::RasterTask* task = it->task;
+      RasterTask* task = it->task;
       DCHECK(!task->HasCompleted());
 
       // First need to run all dependencies.
-      for (internal::ImageDecodeTask::Vector::const_iterator it =
+      for (ImageDecodeTask::Vector::const_iterator it =
                task->dependencies().begin();
            it != task->dependencies().end();
            ++it) {
-        internal::ImageDecodeTask* dependency = it->get();
+        ImageDecodeTask* dependency = it->get();
         if (dependency->HasCompleted())
           continue;
 
@@ -209,8 +206,7 @@ void DirectRasterWorkerPool::RunTasksOnOriginThread() {
   RunTaskOnOriginThread(raster_finished_task_.get());
 }
 
-void DirectRasterWorkerPool::RunTaskOnOriginThread(
-    internal::RasterizerTask* task) {
+void DirectRasterWorkerPool::RunTaskOnOriginThread(RasterizerTask* task) {
   task->WillSchedule();
   task->ScheduleOnOriginThread(this);
   task->DidSchedule();
diff --git a/cc/resources/direct_raster_worker_pool.h b/cc/resources/direct_raster_worker_pool.h
index 15313a6..f2c927b 100644
--- a/cc/resources/direct_raster_worker_pool.h
+++ b/cc/resources/direct_raster_worker_pool.h
@@ -15,7 +15,7 @@ class ResourceProvider;
 
 class CC_EXPORT DirectRasterWorkerPool : public RasterWorkerPool,
                                          public Rasterizer,
-                                         public internal::RasterizerTaskClient {
+                                         public RasterizerTaskClient {
  public:
   virtual ~DirectRasterWorkerPool();
 
@@ -33,9 +33,9 @@ class CC_EXPORT DirectRasterWorkerPool : public RasterWorkerPool,
   virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
   virtual void CheckForCompletedTasks() OVERRIDE;
 
-  // Overridden from internal::RasterizerTaskClient:
-  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterTask* task) OVERRIDE;
-  virtual void ReleaseCanvasForRaster(internal::RasterTask* task) OVERRIDE;
+  // Overridden from RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(RasterTask* task) OVERRIDE;
+  virtual void ReleaseCanvasForRaster(RasterTask* task) OVERRIDE;
 
  private:
   DirectRasterWorkerPool(base::SequencedTaskRunner* task_runner,
@@ -46,7 +46,7 @@ class CC_EXPORT DirectRasterWorkerPool : public RasterWorkerPool,
   void OnRasterRequiredForActivationFinished();
   void ScheduleRunTasksOnOriginThread();
   void RunTasksOnOriginThread();
-  void RunTaskOnOriginThread(internal::RasterizerTask* task);
+  void RunTaskOnOriginThread(RasterizerTask* task);
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   RasterizerClient* client_;
@@ -63,11 +63,10 @@ class CC_EXPORT DirectRasterWorkerPool : public RasterWorkerPool,
   base::WeakPtrFactory<DirectRasterWorkerPool>
       raster_finished_weak_ptr_factory_;
 
-  scoped_refptr<internal::RasterizerTask> raster_finished_task_;
-  scoped_refptr<internal::RasterizerTask>
-      raster_required_for_activation_finished_task_;
+  scoped_refptr<RasterizerTask> raster_finished_task_;
+  scoped_refptr<RasterizerTask> raster_required_for_activation_finished_task_;
 
-  internal::RasterizerTask::Vector completed_tasks_;
+  RasterizerTask::Vector completed_tasks_;
 
   base::WeakPtrFactory<DirectRasterWorkerPool> weak_ptr_factory_;
 
diff --git a/cc/resources/image_raster_worker_pool.cc b/cc/resources/image_raster_worker_pool.cc
index c1434cd..9ce8c6f 100644
--- a/cc/resources/image_raster_worker_pool.cc
+++ b/cc/resources/image_raster_worker_pool.cc
@@ -13,7 +13,7 @@ namespace cc {
 // static
 scoped_ptr<RasterWorkerPool> ImageRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
-    internal::TaskGraphRunner* task_graph_runner,
+    TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider) {
   return make_scoped_ptr<RasterWorkerPool>(new ImageRasterWorkerPool(
       task_runner, task_graph_runner, resource_provider));
@@ -21,7 +21,7 @@ scoped_ptr<RasterWorkerPool> ImageRasterWorkerPool::Create(
 
 ImageRasterWorkerPool::ImageRasterWorkerPool(
     base::SequencedTaskRunner* task_runner,
-    internal::TaskGraphRunner* task_graph_runner,
+    TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider)
     : task_runner_(task_runner),
       task_graph_runner_(task_graph_runner),
@@ -42,7 +42,7 @@ void ImageRasterWorkerPool::SetClient(RasterizerClient* client) {
 void ImageRasterWorkerPool::Shutdown() {
   TRACE_EVENT0("cc", "ImageRasterWorkerPool::Shutdown");
 
-  internal::TaskGraph empty;
+  TaskGraph empty;
   task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
   task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
 }
@@ -69,7 +69,7 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  scoped_refptr<internal::RasterizerTask>
+  scoped_refptr<RasterizerTask>
       new_raster_required_for_activation_finished_task(
           CreateRasterRequiredForActivationFinishedTask(
               queue->required_for_activation_count,
@@ -77,7 +77,7 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
               base::Bind(
                   &ImageRasterWorkerPool::OnRasterRequiredForActivationFinished,
                   raster_finished_weak_ptr_factory_.GetWeakPtr())));
-  scoped_refptr<internal::RasterizerTask> new_raster_finished_task(
+  scoped_refptr<RasterizerTask> new_raster_finished_task(
       CreateRasterFinishedTask(
           task_runner_.get(),
           base::Bind(&ImageRasterWorkerPool::OnRasterFinished,
@@ -87,18 +87,18 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
        it != queue->items.end();
        ++it) {
     const RasterTaskQueue::Item& item = *it;
-    internal::RasterTask* task = item.task;
+    RasterTask* task = item.task;
     DCHECK(!task->HasCompleted());
 
     if (item.required_for_activation) {
-      graph_.edges.push_back(internal::TaskGraph::Edge(
+      graph_.edges.push_back(TaskGraph::Edge(
           task, new_raster_required_for_activation_finished_task.get()));
     }
 
     InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
 
     graph_.edges.push_back(
-        internal::TaskGraph::Edge(task, new_raster_finished_task.get()));
+        TaskGraph::Edge(task, new_raster_finished_task.get()));
   }
 
   InsertNodeForTask(&graph_,
@@ -131,11 +131,10 @@ void ImageRasterWorkerPool::CheckForCompletedTasks() {
 
   task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                             &completed_tasks_);
-  for (internal::Task::Vector::const_iterator it = completed_tasks_.begin();
+  for (Task::Vector::const_iterator it = completed_tasks_.begin();
        it != completed_tasks_.end();
        ++it) {
-    internal::RasterizerTask* task =
-        static_cast<internal::RasterizerTask*>(it->get());
+    RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
 
     task->WillComplete();
     task->CompleteOnOriginThread(this);
@@ -146,12 +145,11 @@ void ImageRasterWorkerPool::CheckForCompletedTasks() {
   completed_tasks_.clear();
 }
 
-SkCanvas* ImageRasterWorkerPool::AcquireCanvasForRaster(
-    internal::RasterTask* task) {
+SkCanvas* ImageRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) {
   return resource_provider_->MapImageRasterBuffer(task->resource()->id());
 }
 
-void ImageRasterWorkerPool::ReleaseCanvasForRaster(internal::RasterTask* task) {
+void ImageRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) {
   resource_provider_->UnmapImageRasterBuffer(task->resource()->id());
 }
 
diff --git a/cc/resources/image_raster_worker_pool.h b/cc/resources/image_raster_worker_pool.h
index 82da770..2e11a22 100644
--- a/cc/resources/image_raster_worker_pool.h
+++ b/cc/resources/image_raster_worker_pool.h
@@ -15,13 +15,13 @@ class ResourceProvider;
 
 class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
                                         public Rasterizer,
-                                        public internal::RasterizerTaskClient {
+                                        public RasterizerTaskClient {
  public:
   virtual ~ImageRasterWorkerPool();
 
   static scoped_ptr<RasterWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
-      internal::TaskGraphRunner* task_graph_runner,
+      TaskGraphRunner* task_graph_runner,
       ResourceProvider* resource_provider);
 
   // Overridden from RasterWorkerPool:
@@ -33,13 +33,13 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
   virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
   virtual void CheckForCompletedTasks() OVERRIDE;
 
-  // Overridden from internal::RasterizerTaskClient:
-  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterTask* task) OVERRIDE;
-  virtual void ReleaseCanvasForRaster(internal::RasterTask* task) OVERRIDE;
+  // Overridden from RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(RasterTask* task) OVERRIDE;
+  virtual void ReleaseCanvasForRaster(RasterTask* task) OVERRIDE;
 
  protected:
   ImageRasterWorkerPool(base::SequencedTaskRunner* task_runner,
-                        internal::TaskGraphRunner* task_graph_runner,
+                        TaskGraphRunner* task_graph_runner,
                         ResourceProvider* resource_provider);
 
  private:
@@ -48,8 +48,8 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
   scoped_ptr<base::Value> StateAsValue() const;
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
-  internal::TaskGraphRunner* task_graph_runner_;
-  const internal::NamespaceToken namespace_token_;
+  TaskGraphRunner* task_graph_runner_;
+  const NamespaceToken namespace_token_;
   RasterizerClient* client_;
   ResourceProvider* resource_provider_;
 
@@ -58,14 +58,13 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
 
   base::WeakPtrFactory<ImageRasterWorkerPool> raster_finished_weak_ptr_factory_;
 
-  scoped_refptr<internal::RasterizerTask> raster_finished_task_;
-  scoped_refptr<internal::RasterizerTask>
-      raster_required_for_activation_finished_task_;
+  scoped_refptr<RasterizerTask> raster_finished_task_;
+  scoped_refptr<RasterizerTask> raster_required_for_activation_finished_task_;
 
   // Task graph used when scheduling tasks and vector used to gather
   // completed tasks.
-  internal::TaskGraph graph_;
-  internal::Task::Vector completed_tasks_;
+  TaskGraph graph_;
+  Task::Vector completed_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRasterWorkerPool);
 };
diff --git a/cc/resources/managed_tile_state.h b/cc/resources/managed_tile_state.h
index 00dcf1a..b3d80bb 100644
--- a/cc/resources/managed_tile_state.h
+++ b/cc/resources/managed_tile_state.h
@@ -102,7 +102,7 @@ class CC_EXPORT ManagedTileState {
     SkColor solid_color_;
     bool has_text_;
     scoped_ptr<ScopedResource> resource_;
-    scoped_refptr<internal::RasterTask> raster_task_;
+    scoped_refptr<RasterTask> raster_task_;
   };
 
   ManagedTileState();
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc
index d51fac6..4383acc 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_raster_worker_pool.cc
@@ -18,7 +18,7 @@ const int kCheckForCompletedRasterTasksDelayMs = 6;
 
 const size_t kMaxScheduledRasterTasks = 48;
 
-typedef base::StackVector<internal::RasterTask*, kMaxScheduledRasterTasks>
+typedef base::StackVector<RasterTask*, kMaxScheduledRasterTasks>
     RasterTaskVector;
 
 }  // namespace
@@ -26,7 +26,7 @@ typedef base::StackVector<internal::RasterTask*, kMaxScheduledRasterTasks>
 // static
 scoped_ptr<RasterWorkerPool> PixelBufferRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
-    internal::TaskGraphRunner* task_graph_runner,
+    TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     size_t max_transfer_buffer_usage_bytes) {
   return make_scoped_ptr<RasterWorkerPool>(
@@ -38,7 +38,7 @@ scoped_ptr<RasterWorkerPool> PixelBufferRasterWorkerPool::Create(
 
 PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
     base::SequencedTaskRunner* task_runner,
-    internal::TaskGraphRunner* task_graph_runner,
+    TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     size_t max_transfer_buffer_usage_bytes)
     : task_runner_(task_runner),
@@ -80,7 +80,7 @@ void PixelBufferRasterWorkerPool::Shutdown() {
 
   shutdown_ = true;
 
-  internal::TaskGraph empty;
+  TaskGraph empty;
   task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
   task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
 
@@ -125,7 +125,7 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
        it != queue->items.end();
        ++it) {
     const RasterTaskQueue::Item& item = *it;
-    internal::RasterTask* task = item.task;
+    RasterTask* task = item.task;
 
     // Remove any old items that are associated with this task. The result is
     // that the old queue is left with all items not present in this queue,
@@ -169,7 +169,7 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
        it != raster_tasks_.items.end();
        ++it) {
     const RasterTaskQueue::Item& item = *it;
-    internal::RasterTask* task = item.task;
+    RasterTask* task = item.task;
 
     RasterTaskState::Vector::iterator state_it =
         std::find_if(raster_task_states_.begin(),
@@ -229,20 +229,19 @@ void PixelBufferRasterWorkerPool::CheckForCompletedTasks() {
   CheckForCompletedUploads();
   FlushUploads();
 
-  for (internal::RasterizerTask::Vector::const_iterator it =
+  for (RasterizerTask::Vector::const_iterator it =
            completed_image_decode_tasks_.begin();
        it != completed_image_decode_tasks_.end();
        ++it) {
-    internal::RasterizerTask* task = it->get();
+    RasterizerTask* task = it->get();
     task->RunReplyOnOriginThread();
   }
   completed_image_decode_tasks_.clear();
 
-  for (internal::RasterTask::Vector::const_iterator it =
-           completed_raster_tasks_.begin();
+  for (RasterTask::Vector::const_iterator it = completed_raster_tasks_.begin();
        it != completed_raster_tasks_.end();
        ++it) {
-    internal::RasterTask* task = it->get();
+    RasterTask* task = it->get();
     RasterTaskState::Vector::iterator state_it =
         std::find_if(raster_task_states_.begin(),
                      raster_task_states_.end(),
@@ -259,7 +258,7 @@ void PixelBufferRasterWorkerPool::CheckForCompletedTasks() {
 }
 
 SkCanvas* PixelBufferRasterWorkerPool::AcquireCanvasForRaster(
-    internal::RasterTask* task) {
+    RasterTask* task) {
   DCHECK(std::find_if(raster_task_states_.begin(),
                       raster_task_states_.end(),
                       RasterTaskState::TaskComparator(task)) !=
@@ -268,8 +267,7 @@ SkCanvas* PixelBufferRasterWorkerPool::AcquireCanvasForRaster(
   return resource_provider_->MapPixelRasterBuffer(task->resource()->id());
 }
 
-void PixelBufferRasterWorkerPool::ReleaseCanvasForRaster(
-    internal::RasterTask* task) {
+void PixelBufferRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) {
   DCHECK(std::find_if(raster_task_states_.begin(),
                       raster_task_states_.end(),
                       RasterTaskState::TaskComparator(task)) !=
@@ -320,12 +318,11 @@ void PixelBufferRasterWorkerPool::FlushUploads() {
 }
 
 void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
-  internal::RasterTask::Vector tasks_with_completed_uploads;
+  RasterTask::Vector tasks_with_completed_uploads;
 
   // First check if any have completed.
   while (!raster_tasks_with_pending_upload_.empty()) {
-    internal::RasterTask* task =
-        raster_tasks_with_pending_upload_.front().get();
+    RasterTask* task = raster_tasks_with_pending_upload_.front().get();
     DCHECK(std::find_if(raster_task_states_.begin(),
                         raster_task_states_.end(),
                         RasterTaskState::TaskComparator(task)) !=
@@ -348,10 +345,10 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
       shutdown_ || client_->ShouldForceTasksRequiredForActivationToComplete();
 
   if (should_force_some_uploads_to_complete) {
-    internal::RasterTask::Vector tasks_with_uploads_to_force;
+    RasterTask::Vector tasks_with_uploads_to_force;
     RasterTaskDeque::iterator it = raster_tasks_with_pending_upload_.begin();
     while (it != raster_tasks_with_pending_upload_.end()) {
-      internal::RasterTask* task = it->get();
+      RasterTask* task = it->get();
       RasterTaskState::Vector::const_iterator state_it =
           std::find_if(raster_task_states_.begin(),
                        raster_task_states_.end(),
@@ -373,11 +370,11 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
 
     // Force uploads in reverse order. Since forcing can cause a wait on
     // all previous uploads, we would rather wait only once downstream.
-    for (internal::RasterTask::Vector::reverse_iterator it =
+    for (RasterTask::Vector::reverse_iterator it =
              tasks_with_uploads_to_force.rbegin();
          it != tasks_with_uploads_to_force.rend();
          ++it) {
-      internal::RasterTask* task = it->get();
+      RasterTask* task = it->get();
 
       resource_provider_->ForceSetPixelsToComplete(task->resource()->id());
       has_performed_uploads_since_last_flush_ = true;
@@ -386,11 +383,11 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
 
   // Release shared memory and move tasks with completed uploads
   // to |completed_raster_tasks_|.
-  for (internal::RasterTask::Vector::const_iterator it =
+  for (RasterTask::Vector::const_iterator it =
            tasks_with_completed_uploads.begin();
        it != tasks_with_completed_uploads.end();
        ++it) {
-    internal::RasterTask* task = it->get();
+    RasterTask* task = it->get();
     RasterTaskState::Vector::iterator state_it =
         std::find_if(raster_task_states_.begin(),
                      raster_task_states_.end(),
@@ -532,7 +529,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
        it != raster_tasks_.items.end();
        ++it) {
     const RasterTaskQueue::Item& item = *it;
-    internal::RasterTask* task = item.task;
+    RasterTask* task = item.task;
 
     // |raster_task_states_| contains the state of all tasks that we have not
     // yet run reply callbacks for.
@@ -596,7 +593,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  scoped_refptr<internal::RasterizerTask>
+  scoped_refptr<RasterizerTask>
       new_raster_required_for_activation_finished_task;
 
   size_t scheduled_raster_task_required_for_activation_count =
@@ -624,12 +621,12 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
              tasks_required_for_activation.container().begin();
          it != tasks_required_for_activation.container().end();
          ++it) {
-      graph_.edges.push_back(internal::TaskGraph::Edge(
+      graph_.edges.push_back(TaskGraph::Edge(
           *it, new_raster_required_for_activation_finished_task.get()));
     }
   }
 
-  scoped_refptr<internal::RasterizerTask> new_raster_finished_task;
+  scoped_refptr<RasterizerTask> new_raster_finished_task;
 
   size_t scheduled_raster_task_count = tasks.container().size();
   DCHECK_LE(scheduled_raster_task_count, PendingRasterTaskCount());
@@ -651,7 +648,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
          it != tasks.container().end();
          ++it) {
       graph_.edges.push_back(
-          internal::TaskGraph::Edge(*it, new_raster_finished_task.get()));
+          TaskGraph::Edge(*it, new_raster_finished_task.get()));
     }
   }
 
@@ -697,13 +694,12 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterizerTasks() {
 
   task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                             &completed_tasks_);
-  for (internal::Task::Vector::const_iterator it = completed_tasks_.begin();
+  for (Task::Vector::const_iterator it = completed_tasks_.begin();
        it != completed_tasks_.end();
        ++it) {
-    internal::RasterizerTask* task =
-        static_cast<internal::RasterizerTask*>(it->get());
+    RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
 
-    internal::RasterTask* raster_task = task->AsRasterTask();
+    RasterTask* raster_task = task->AsRasterTask();
     if (!raster_task) {
       task->WillComplete();
       task->CompleteOnOriginThread(this);
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.h b/cc/resources/pixel_buffer_raster_worker_pool.h
index f7abab1..4f1c435 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.h
+++ b/cc/resources/pixel_buffer_raster_worker_pool.h
@@ -16,16 +16,15 @@
 namespace cc {
 class ResourceProvider;
 
-class CC_EXPORT PixelBufferRasterWorkerPool
-    : public RasterWorkerPool,
-      public Rasterizer,
-      public internal::RasterizerTaskClient {
+class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool,
+                                              public Rasterizer,
+                                              public RasterizerTaskClient {
  public:
   virtual ~PixelBufferRasterWorkerPool();
 
   static scoped_ptr<RasterWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
-      internal::TaskGraphRunner* task_graph_runner,
+      TaskGraphRunner* task_graph_runner,
       ResourceProvider* resource_provider,
       size_t max_transfer_buffer_usage_bytes);
 
@@ -38,40 +37,40 @@ class CC_EXPORT PixelBufferRasterWorkerPool
   virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
   virtual void CheckForCompletedTasks() OVERRIDE;
 
-  // Overridden from internal::RasterizerTaskClient:
-  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterTask* task) OVERRIDE;
-  virtual void ReleaseCanvasForRaster(internal::RasterTask* task) OVERRIDE;
+  // Overridden from RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(RasterTask* task) OVERRIDE;
+  virtual void ReleaseCanvasForRaster(RasterTask* task) OVERRIDE;
 
  private:
   struct RasterTaskState {
     class TaskComparator {
      public:
-      explicit TaskComparator(const internal::RasterTask* task) : task_(task) {}
+      explicit TaskComparator(const RasterTask* task) : task_(task) {}
 
       bool operator()(const RasterTaskState& state) const {
         return state.task == task_;
       }
 
      private:
-      const internal::RasterTask* task_;
+      const RasterTask* task_;
     };
 
     typedef std::vector<RasterTaskState> Vector;
 
-    RasterTaskState(internal::RasterTask* task, bool required_for_activation)
+    RasterTaskState(RasterTask* task, bool required_for_activation)
         : type(UNSCHEDULED),
           task(task),
           required_for_activation(required_for_activation) {}
 
     enum { UNSCHEDULED, SCHEDULED, UPLOADING, COMPLETED } type;
-    internal::RasterTask* task;
+    RasterTask* task;
     bool required_for_activation;
   };
 
-  typedef std::deque<scoped_refptr<internal::RasterTask> > RasterTaskDeque;
+  typedef std::deque<scoped_refptr<RasterTask> > RasterTaskDeque;
 
   PixelBufferRasterWorkerPool(base::SequencedTaskRunner* task_runner,
-                              internal::TaskGraphRunner* task_graph_runner,
+                              TaskGraphRunner* task_graph_runner,
                               ResourceProvider* resource_provider,
                               size_t max_transfer_buffer_usage_bytes);
 
@@ -93,8 +92,8 @@ class CC_EXPORT PixelBufferRasterWorkerPool
   scoped_ptr<base::Value> ThrottleStateAsValue() const;
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
-  internal::TaskGraphRunner* task_graph_runner_;
-  const internal::NamespaceToken namespace_token_;
+  TaskGraphRunner* task_graph_runner_;
+  const NamespaceToken namespace_token_;
   RasterizerClient* client_;
   ResourceProvider* resource_provider_;
 
@@ -103,8 +102,8 @@ class CC_EXPORT PixelBufferRasterWorkerPool
   RasterTaskQueue raster_tasks_;
   RasterTaskState::Vector raster_task_states_;
   RasterTaskDeque raster_tasks_with_pending_upload_;
-  internal::RasterTask::Vector completed_raster_tasks_;
-  internal::RasterizerTask::Vector completed_image_decode_tasks_;
+  RasterTask::Vector completed_raster_tasks_;
+  RasterizerTask::Vector completed_image_decode_tasks_;
 
   size_t scheduled_raster_task_count_;
   size_t raster_tasks_required_for_activation_count_;
@@ -122,14 +121,13 @@ class CC_EXPORT PixelBufferRasterWorkerPool
   base::WeakPtrFactory<PixelBufferRasterWorkerPool>
       raster_finished_weak_ptr_factory_;
 
-  scoped_refptr<internal::RasterizerTask> raster_finished_task_;
-  scoped_refptr<internal::RasterizerTask>
-      raster_required_for_activation_finished_task_;
+  scoped_refptr<RasterizerTask> raster_finished_task_;
+  scoped_refptr<RasterizerTask> raster_required_for_activation_finished_task_;
 
   // Task graph used when scheduling tasks and vector used to gather
   // completed tasks.
-  internal::TaskGraph graph_;
-  internal::Task::Vector completed_tasks_;
+  TaskGraph graph_;
+  Task::Vector completed_tasks_;
 
   base::WeakPtrFactory<PixelBufferRasterWorkerPool> weak_ptr_factory_;
 
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index d012894..e7b3f13 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -28,7 +28,7 @@ struct RasterRequiredForActivationSyntheticDelayInitializer {
 static base::LazyInstance<RasterRequiredForActivationSyntheticDelayInitializer>
     g_raster_required_for_activation_delay = LAZY_INSTANCE_INITIALIZER;
 
-class RasterTaskGraphRunner : public internal::TaskGraphRunner,
+class RasterTaskGraphRunner : public TaskGraphRunner,
                               public base::DelegateSimpleThread::Delegate {
  public:
   RasterTaskGraphRunner() {
@@ -70,7 +70,7 @@ class RasterTaskGraphRunner : public internal::TaskGraphRunner,
     DCHECK_GT(RasterWorkerPool::GetNumRasterThreads(), picture_clone_index);
     current_tls_.Set(new ThreadLocalState(picture_clone_index));
 
-    internal::TaskGraphRunner::Run();
+    TaskGraphRunner::Run();
   }
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
@@ -85,7 +85,7 @@ const int kDefaultNumRasterThreads = 1;
 
 int g_num_raster_threads = 0;
 
-class RasterFinishedTaskImpl : public internal::RasterizerTask {
+class RasterFinishedTaskImpl : public RasterizerTask {
  public:
   explicit RasterFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
@@ -93,21 +93,19 @@ class RasterFinishedTaskImpl : public internal::RasterizerTask {
       : task_runner_(task_runner),
         on_raster_finished_callback_(on_raster_finished_callback) {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnWorkerThread");
     RasterFinished();
   }
 
-  // Overridden from internal::RasterizerTask:
-  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {}
+  // Overridden from RasterizerTask:
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
   virtual void RunOnOriginThread() OVERRIDE {
     TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnOriginThread");
     RasterFinished();
   }
-  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {}
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
@@ -140,14 +138,14 @@ class RasterRequiredForActivationFinishedTaskImpl
     }
   }
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     TRACE_EVENT0(
         "cc", "RasterRequiredForActivationFinishedTaskImpl::RunOnWorkerThread");
     RunRasterFinished();
   }
 
-  // Overridden from internal::RasterizerTask:
+  // Overridden from RasterizerTask:
   virtual void RunOnOriginThread() OVERRIDE {
     TRACE_EVENT0(
         "cc", "RasterRequiredForActivationFinishedTaskImpl::RunOnOriginThread");
@@ -207,7 +205,7 @@ int RasterWorkerPool::GetNumRasterThreads() {
 }
 
 // static
-internal::TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
+TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
   return g_task_graph_runner.Pointer();
 }
 
@@ -217,8 +215,7 @@ size_t RasterWorkerPool::GetPictureCloneIndexForCurrentThread() {
 }
 
 // static
-scoped_refptr<internal::RasterizerTask>
-RasterWorkerPool::CreateRasterFinishedTask(
+scoped_refptr<RasterizerTask> RasterWorkerPool::CreateRasterFinishedTask(
     base::SequencedTaskRunner* task_runner,
     const base::Closure& on_raster_finished_callback) {
   return make_scoped_refptr(
@@ -226,7 +223,7 @@ RasterWorkerPool::CreateRasterFinishedTask(
 }
 
 // static
-scoped_refptr<internal::RasterizerTask>
+scoped_refptr<RasterizerTask>
 RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
     size_t tasks_required_for_activation_count,
     base::SequencedTaskRunner* task_runner,
@@ -238,17 +235,15 @@ RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
 }
 
 // static
-void RasterWorkerPool::ScheduleTasksOnOriginThread(
-    internal::RasterizerTaskClient* client,
-    internal::TaskGraph* graph) {
+void RasterWorkerPool::ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
+                                                   TaskGraph* graph) {
   TRACE_EVENT0("cc", "Rasterizer::ScheduleTasksOnOriginThread");
 
-  for (internal::TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
+  for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
        it != graph->nodes.end();
        ++it) {
-    internal::TaskGraph::Node& node = *it;
-    internal::RasterizerTask* task =
-        static_cast<internal::RasterizerTask*>(node.task);
+    TaskGraph::Node& node = *it;
+    RasterizerTask* task = static_cast<RasterizerTask*>(node.task);
 
     if (!task->HasBeenScheduled()) {
       task->WillSchedule();
@@ -259,32 +254,30 @@ void RasterWorkerPool::ScheduleTasksOnOriginThread(
 }
 
 // static
-void RasterWorkerPool::InsertNodeForTask(internal::TaskGraph* graph,
-                                         internal::RasterizerTask* task,
+void RasterWorkerPool::InsertNodeForTask(TaskGraph* graph,
+                                         RasterizerTask* task,
                                          unsigned priority,
                                          size_t dependencies) {
   DCHECK(std::find_if(graph->nodes.begin(),
                       graph->nodes.end(),
-                      internal::TaskGraph::Node::TaskComparator(task)) ==
+                      TaskGraph::Node::TaskComparator(task)) ==
          graph->nodes.end());
-  graph->nodes.push_back(
-      internal::TaskGraph::Node(task, priority, dependencies));
+  graph->nodes.push_back(TaskGraph::Node(task, priority, dependencies));
 }
 
 // static
 void RasterWorkerPool::InsertNodesForRasterTask(
-    internal::TaskGraph* graph,
-    internal::RasterTask* raster_task,
-    const internal::ImageDecodeTask::Vector& decode_tasks,
+    TaskGraph* graph,
+    RasterTask* raster_task,
+    const ImageDecodeTask::Vector& decode_tasks,
     unsigned priority) {
   size_t dependencies = 0u;
 
   // Insert image decode tasks.
-  for (internal::ImageDecodeTask::Vector::const_iterator it =
-           decode_tasks.begin();
+  for (ImageDecodeTask::Vector::const_iterator it = decode_tasks.begin();
        it != decode_tasks.end();
        ++it) {
-    internal::ImageDecodeTask* decode_task = it->get();
+    ImageDecodeTask* decode_task = it->get();
 
     // Skip if already decoded.
     if (decode_task->HasCompleted())
@@ -293,14 +286,14 @@ void RasterWorkerPool::InsertNodesForRasterTask(
     dependencies++;
 
     // Add decode task if it doesn't already exists in graph.
-    internal::TaskGraph::Node::Vector::iterator decode_it =
+    TaskGraph::Node::Vector::iterator decode_it =
         std::find_if(graph->nodes.begin(),
                      graph->nodes.end(),
-                     internal::TaskGraph::Node::TaskComparator(decode_task));
+                     TaskGraph::Node::TaskComparator(decode_task));
     if (decode_it == graph->nodes.end())
       InsertNodeForTask(graph, decode_task, priority, 0u);
 
-    graph->edges.push_back(internal::TaskGraph::Edge(decode_task, raster_task));
+    graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, priority, dependencies);
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index 3eedc6c..2c543a0 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -33,7 +33,7 @@ class CC_EXPORT RasterWorkerPool {
   static int GetNumRasterThreads();
 
   // Returns a pointer to the global TaskGraphRunner instance.
-  static internal::TaskGraphRunner* GetTaskGraphRunner();
+  static TaskGraphRunner* GetTaskGraphRunner();
 
   // Returns a unique clone index for the current thread. Guaranteed to be a
   // value between 0 and GetNumRasterThreads() - 1.
@@ -41,13 +41,13 @@ class CC_EXPORT RasterWorkerPool {
 
   // Utility function that can be used to create a "raster finished" task that
   // posts |callback| to |task_runner| when run.
-  static scoped_refptr<internal::RasterizerTask> CreateRasterFinishedTask(
+  static scoped_refptr<RasterizerTask> CreateRasterFinishedTask(
       base::SequencedTaskRunner* task_runner,
       const base::Closure& callback);
 
   // Utility function that can be used to create a "raster required for
   // activation finished" task that posts |callback| to |task_runner| when run.
-  static scoped_refptr<internal::RasterizerTask>
+  static scoped_refptr<RasterizerTask>
       CreateRasterRequiredForActivationFinishedTask(
           size_t tasks_required_for_activation_count,
           base::SequencedTaskRunner* task_runner,
@@ -55,24 +55,23 @@ class CC_EXPORT RasterWorkerPool {
 
   // Utility function that can be used to call ::ScheduleOnOriginThread() for
   // each task in |graph|.
-  static void ScheduleTasksOnOriginThread(
-      internal::RasterizerTaskClient* client,
-      internal::TaskGraph* graph);
+  static void ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
+                                          TaskGraph* graph);
 
   // Utility function that can be used to build a task graph. Inserts a node
   // that represents |task| in |graph|. See TaskGraph definition for valid
   // |priority| values.
-  static void InsertNodeForTask(internal::TaskGraph* graph,
-                                internal::RasterizerTask* task,
+  static void InsertNodeForTask(TaskGraph* graph,
+                                RasterizerTask* task,
                                 unsigned priority,
                                 size_t dependencies);
 
   // Utility function that can be used to build a task graph. Inserts nodes that
   // represent |task| and all its image decode dependencies in |graph|.
   static void InsertNodesForRasterTask(
-      internal::TaskGraph* graph,
-      internal::RasterTask* task,
-      const internal::ImageDecodeTask::Vector& decode_tasks,
+      TaskGraph* graph,
+      RasterTask* task,
+      const ImageDecodeTask::Vector& decode_tasks,
       unsigned priority);
 
   // Type-checking downcast routine.
diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc
index fda6bbc..f99c293 100644
--- a/cc/resources/raster_worker_pool_perftest.cc
+++ b/cc/resources/raster_worker_pool_perftest.cc
@@ -81,19 +81,17 @@ static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
-class PerfImageDecodeTaskImpl : public internal::ImageDecodeTask {
+class PerfImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   PerfImageDecodeTaskImpl() {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {}
 
-  // Overridden from internal::RasterizerTask:
-  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {}
+  // Overridden from RasterizerTask:
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
   virtual void RunOnOriginThread() OVERRIDE {}
-  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {}
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
   virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }
 
   void Reset() {
@@ -108,24 +106,21 @@ class PerfImageDecodeTaskImpl : public internal::ImageDecodeTask {
   DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl);
 };
 
-class PerfRasterTaskImpl : public internal::RasterTask {
+class PerfRasterTaskImpl : public RasterTask {
  public:
   PerfRasterTaskImpl(scoped_ptr<ScopedResource> resource,
-                     internal::ImageDecodeTask::Vector* dependencies)
-      : internal::RasterTask(resource.get(), dependencies),
-        resource_(resource.Pass()) {}
+                     ImageDecodeTask::Vector* dependencies)
+      : RasterTask(resource.get(), dependencies), resource_(resource.Pass()) {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {}
 
-  // Overridden from internal::RasterizerTask:
-  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {
+  // Overridden from RasterizerTask:
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
     client->AcquireCanvasForRaster(this);
   }
   virtual void RunOnOriginThread() OVERRIDE {}
-  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
     client->ReleaseCanvasForRaster(this);
   }
   virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }
@@ -146,11 +141,11 @@ class PerfRasterTaskImpl : public internal::RasterTask {
 
 class RasterWorkerPoolPerfTestBase {
  public:
-  typedef std::vector<scoped_refptr<internal::RasterTask> > RasterTaskVector;
+  typedef std::vector<scoped_refptr<RasterTask> > RasterTaskVector;
 
   RasterWorkerPoolPerfTestBase()
       : context_provider_(make_scoped_refptr(new PerfContextProvider)),
-        task_graph_runner_(new internal::TaskGraphRunner),
+        task_graph_runner_(new TaskGraphRunner),
         timer_(kWarmupRuns,
                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
                kTimeCheckInterval) {
@@ -164,17 +159,15 @@ class RasterWorkerPoolPerfTestBase {
             .Pass();
   }
 
-  void CreateImageDecodeTasks(
-      unsigned num_image_decode_tasks,
-      internal::ImageDecodeTask::Vector* image_decode_tasks) {
+  void CreateImageDecodeTasks(unsigned num_image_decode_tasks,
+                              ImageDecodeTask::Vector* image_decode_tasks) {
     for (unsigned i = 0; i < num_image_decode_tasks; ++i)
       image_decode_tasks->push_back(new PerfImageDecodeTaskImpl);
   }
 
-  void CreateRasterTasks(
-      unsigned num_raster_tasks,
-      const internal::ImageDecodeTask::Vector& image_decode_tasks,
-      RasterTaskVector* raster_tasks) {
+  void CreateRasterTasks(unsigned num_raster_tasks,
+                         const ImageDecodeTask::Vector& image_decode_tasks,
+                         RasterTaskVector* raster_tasks) {
     const gfx::Size size(1, 1);
 
     for (unsigned i = 0; i < num_raster_tasks; ++i) {
@@ -182,7 +175,7 @@ class RasterWorkerPoolPerfTestBase {
           ScopedResource::Create(resource_provider_.get()));
       resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
 
-      internal::ImageDecodeTask::Vector dependencies = image_decode_tasks;
+      ImageDecodeTask::Vector dependencies = image_decode_tasks;
       raster_tasks->push_back(
           new PerfRasterTaskImpl(resource.Pass(), &dependencies));
     }
@@ -204,7 +197,7 @@ class RasterWorkerPoolPerfTestBase {
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
-  scoped_ptr<internal::TaskGraphRunner> task_graph_runner_;
+  scoped_ptr<TaskGraphRunner> task_graph_runner_;
   LapTimer timer_;
 };
 
@@ -265,7 +258,7 @@ class RasterWorkerPoolPerfTest
   void RunScheduleTasksTest(const std::string& test_name,
                             unsigned num_raster_tasks,
                             unsigned num_image_decode_tasks) {
-    internal::ImageDecodeTask::Vector image_decode_tasks;
+    ImageDecodeTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
@@ -298,7 +291,7 @@ class RasterWorkerPoolPerfTest
                                      unsigned num_raster_tasks,
                                      unsigned num_image_decode_tasks) {
     const size_t kNumVersions = 2;
-    internal::ImageDecodeTask::Vector image_decode_tasks[kNumVersions];
+    ImageDecodeTask::Vector image_decode_tasks[kNumVersions];
     RasterTaskVector raster_tasks[kNumVersions];
     for (size_t i = 0; i < kNumVersions; ++i) {
       CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);
@@ -335,7 +328,7 @@ class RasterWorkerPoolPerfTest
   void RunScheduleAndExecuteTasksTest(const std::string& test_name,
                                       unsigned num_raster_tasks,
                                       unsigned num_image_decode_tasks) {
-    internal::ImageDecodeTask::Vector image_decode_tasks;
+    ImageDecodeTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
@@ -420,7 +413,7 @@ class RasterWorkerPoolCommonPerfTest : public RasterWorkerPoolPerfTestBase,
   void RunBuildRasterTaskQueueTest(const std::string& test_name,
                                    unsigned num_raster_tasks,
                                    unsigned num_image_decode_tasks) {
-    internal::ImageDecodeTask::Vector image_decode_tasks;
+    ImageDecodeTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index 4385e26..aff7461 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -37,7 +37,7 @@ enum RasterWorkerPoolType {
   RASTER_WORKER_POOL_TYPE_DIRECT
 };
 
-class TestRasterTaskImpl : public internal::RasterTask {
+class TestRasterTaskImpl : public RasterTask {
  public:
   typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
                               bool was_canceled,
@@ -45,26 +45,24 @@ class TestRasterTaskImpl : public internal::RasterTask {
 
   TestRasterTaskImpl(const Resource* resource,
                      const Reply& reply,
-                     internal::ImageDecodeTask::Vector* dependencies)
-      : internal::RasterTask(resource, dependencies),
+                     ImageDecodeTask::Vector* dependencies)
+      : RasterTask(resource, dependencies),
         reply_(reply),
         raster_thread_(RASTER_THREAD_NONE) {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     raster_thread_ = RASTER_THREAD_WORKER;
   }
 
-  // Overridden from internal::RasterizerTask:
-  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {
+  // Overridden from RasterizerTask:
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
     client->AcquireCanvasForRaster(this);
   }
   virtual void RunOnOriginThread() OVERRIDE {
     raster_thread_ = RASTER_THREAD_ORIGIN;
   }
-  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
     client->ReleaseCanvasForRaster(this);
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
@@ -87,16 +85,16 @@ class BlockingTestRasterTaskImpl : public TestRasterTaskImpl {
   BlockingTestRasterTaskImpl(const Resource* resource,
                              const Reply& reply,
                              base::Lock* lock,
-                             internal::ImageDecodeTask::Vector* dependencies)
+                             ImageDecodeTask::Vector* dependencies)
       : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     base::AutoLock lock(*lock_);
     TestRasterTaskImpl::RunOnWorkerThread();
   }
 
-  // Overridden from internal::RasterizerTask:
+  // Overridden from RasterizerTask:
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
@@ -118,7 +116,7 @@ class RasterWorkerPoolTest
     RasterThread raster_thread;
   };
 
-  typedef std::vector<scoped_refptr<internal::RasterTask> > RasterTaskVector;
+  typedef std::vector<scoped_refptr<RasterTask> > RasterTaskVector;
 
   RasterWorkerPoolTest()
       : context_provider_(TestContextProvider::Create()),
@@ -213,7 +211,7 @@ class RasterWorkerPoolTest
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    internal::ImageDecodeTask::Vector empty;
+    ImageDecodeTask::Vector empty;
     tasks_.push_back(new TestRasterTaskImpl(
         const_resource,
         base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
@@ -231,7 +229,7 @@ class RasterWorkerPoolTest
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    internal::ImageDecodeTask::Vector empty;
+    ImageDecodeTask::Vector empty;
     tasks_.push_back(new BlockingTestRasterTaskImpl(
         const_resource,
         base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
diff --git a/cc/resources/rasterizer.cc b/cc/resources/rasterizer.cc
index 5282d85..563690d 100644
--- a/cc/resources/rasterizer.cc
+++ b/cc/resources/rasterizer.cc
@@ -7,7 +7,6 @@
 #include <algorithm>
 
 namespace cc {
-namespace internal {
 
 RasterizerTask::RasterizerTask() : did_schedule_(false), did_complete_(false) {}
 
@@ -47,7 +46,7 @@ ImageDecodeTask::~ImageDecodeTask() {}
 ImageDecodeTask* ImageDecodeTask::AsImageDecodeTask() { return this; }
 
 RasterTask::RasterTask(const Resource* resource,
-                       internal::ImageDecodeTask::Vector* dependencies)
+                       ImageDecodeTask::Vector* dependencies)
     : resource_(resource) {
   dependencies_.swap(*dependencies);
 }
@@ -56,10 +55,7 @@ RasterTask::~RasterTask() {}
 
 RasterTask* RasterTask::AsRasterTask() { return this; }
 
-}  // namespace internal
-
-RasterTaskQueue::Item::Item(internal::RasterTask* task,
-                            bool required_for_activation)
+RasterTaskQueue::Item::Item(RasterTask* task, bool required_for_activation)
     : task(task), required_for_activation(required_for_activation) {}
 
 RasterTaskQueue::Item::~Item() {}
diff --git a/cc/resources/rasterizer.h b/cc/resources/rasterizer.h
index 432256d..5467d90 100644
--- a/cc/resources/rasterizer.h
+++ b/cc/resources/rasterizer.h
@@ -14,10 +14,9 @@
 class SkCanvas;
 
 namespace cc {
-class Resource;
-
-namespace internal {
+class ImageDecodeTask;
 class RasterTask;
+class Resource;
 
 class CC_EXPORT RasterizerTaskClient {
  public:
@@ -28,8 +27,6 @@ class CC_EXPORT RasterizerTaskClient {
   virtual ~RasterizerTaskClient() {}
 };
 
-class ImageDecodeTask;
-
 class CC_EXPORT RasterizerTask : public Task {
  public:
   typedef std::vector<scoped_refptr<RasterizerTask> > Vector;
@@ -90,8 +87,6 @@ class CC_EXPORT RasterTask : public RasterizerTask {
   ImageDecodeTask::Vector dependencies_;
 };
 
-}  // namespace internal
-
 class CC_EXPORT RasterizerClient {
  public:
   virtual bool ShouldForceTasksRequiredForActivationToComplete() const = 0;
@@ -106,24 +101,24 @@ struct CC_EXPORT RasterTaskQueue {
   struct CC_EXPORT Item {
     class TaskComparator {
      public:
-      explicit TaskComparator(const internal::RasterTask* task) : task_(task) {}
+      explicit TaskComparator(const RasterTask* task) : task_(task) {}
 
       bool operator()(const Item& item) const { return item.task == task_; }
 
      private:
-      const internal::RasterTask* task_;
+      const RasterTask* task_;
     };
 
     typedef std::vector<Item> Vector;
 
-    Item(internal::RasterTask* task, bool required_for_activation);
+    Item(RasterTask* task, bool required_for_activation);
     ~Item();
 
     static bool IsRequiredForActivation(const Item& item) {
       return item.required_for_activation;
     }
 
-    internal::RasterTask* task;
+    RasterTask* task;
     bool required_for_activation;
   };
 
diff --git a/cc/resources/task_graph_runner.cc b/cc/resources/task_graph_runner.cc
index 21a02f9..18cc012 100644
--- a/cc/resources/task_graph_runner.cc
+++ b/cc/resources/task_graph_runner.cc
@@ -11,7 +11,6 @@
 #include "base/threading/thread_restrictions.h"
 
 namespace cc {
-namespace internal {
 namespace {
 
 // Helper class for iterating over all dependents of a task.
@@ -466,5 +465,4 @@ void TaskGraphRunner::RunTaskWithLockAcquired() {
     has_namespaces_with_finished_running_tasks_cv_.Signal();
 }
 
-}  // namespace internal
 }  // namespace cc
diff --git a/cc/resources/task_graph_runner.h b/cc/resources/task_graph_runner.h
index f1b4c74..9dc17f5 100644
--- a/cc/resources/task_graph_runner.h
+++ b/cc/resources/task_graph_runner.h
@@ -14,7 +14,6 @@
 #include "cc/base/cc_export.h"
 
 namespace cc {
-namespace internal {
 
 class CC_EXPORT Task : public base::RefCountedThreadSafe<Task> {
  public:
@@ -227,7 +226,6 @@ class CC_EXPORT TaskGraphRunner {
   DISALLOW_COPY_AND_ASSIGN(TaskGraphRunner);
 };
 
-}  // namespace internal
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TASK_GRAPH_RUNNER_H_
diff --git a/cc/resources/task_graph_runner_perftest.cc b/cc/resources/task_graph_runner_perftest.cc
index 8039b6c..2dff063 100644
--- a/cc/resources/task_graph_runner_perftest.cc
+++ b/cc/resources/task_graph_runner_perftest.cc
@@ -20,13 +20,13 @@ static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
-class PerfTaskImpl : public internal::Task {
+class PerfTaskImpl : public Task {
  public:
   typedef std::vector<scoped_refptr<PerfTaskImpl> > Vector;
 
   PerfTaskImpl() {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {}
 
   void Reset() { did_run_ = false; }
@@ -46,7 +46,7 @@ class TaskGraphRunnerPerfTest : public testing::Test {
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
-    task_graph_runner_ = make_scoped_ptr(new internal::TaskGraphRunner);
+    task_graph_runner_ = make_scoped_ptr(new TaskGraphRunner);
     namespace_token_ = task_graph_runner_->GetNamespaceToken();
   }
   virtual void TearDown() OVERRIDE { task_graph_runner_.reset(); }
@@ -69,7 +69,7 @@ class TaskGraphRunnerPerfTest : public testing::Test {
     CreateTasks(num_leaf_tasks, &leaf_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph.
-    internal::TaskGraph graph;
+    TaskGraph graph;
 
     timer_.Reset();
     do {
@@ -99,8 +99,8 @@ class TaskGraphRunnerPerfTest : public testing::Test {
 
     // Avoid unnecessary heap allocations by reusing the same graph and
     // completed tasks vector.
-    internal::TaskGraph graph;
-    internal::Task::Vector completed_tasks;
+    TaskGraph graph;
+    Task::Vector completed_tasks;
 
     timer_.Reset();
     do {
@@ -113,7 +113,7 @@ class TaskGraphRunnerPerfTest : public testing::Test {
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
-    internal::TaskGraph empty;
+    TaskGraph empty;
     task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
     CollectCompletedTasks(&completed_tasks);
 
@@ -141,8 +141,8 @@ class TaskGraphRunnerPerfTest : public testing::Test {
 
     // Avoid unnecessary heap allocations by reusing the same graph and
     // completed tasks vector.
-    internal::TaskGraph graph;
-    internal::Task::Vector completed_tasks;
+    TaskGraph graph;
+    Task::Vector completed_tasks;
 
     size_t count = 0;
     timer_.Reset();
@@ -159,7 +159,7 @@ class TaskGraphRunnerPerfTest : public testing::Test {
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
-    internal::TaskGraph empty;
+    TaskGraph empty;
     task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
     CollectCompletedTasks(&completed_tasks);
 
@@ -184,8 +184,8 @@ class TaskGraphRunnerPerfTest : public testing::Test {
 
     // Avoid unnecessary heap allocations by reusing the same graph and
     // completed tasks vector.
-    internal::TaskGraph graph;
-    internal::Task::Vector completed_tasks;
+    TaskGraph graph;
+    Task::Vector completed_tasks;
 
     timer_.Reset();
     do {
@@ -230,55 +230,51 @@ class TaskGraphRunnerPerfTest : public testing::Test {
   void BuildTaskGraph(const PerfTaskImpl::Vector& top_level_tasks,
                       const PerfTaskImpl::Vector& tasks,
                       const PerfTaskImpl::Vector& leaf_tasks,
-                      internal::TaskGraph* graph) {
+                      TaskGraph* graph) {
     DCHECK(graph->nodes.empty());
     DCHECK(graph->edges.empty());
 
     for (PerfTaskImpl::Vector::const_iterator it = leaf_tasks.begin();
          it != leaf_tasks.end();
          ++it) {
-      graph->nodes.push_back(internal::TaskGraph::Node(it->get(), 0u, 0u));
+      graph->nodes.push_back(TaskGraph::Node(it->get(), 0u, 0u));
     }
 
     for (PerfTaskImpl::Vector::const_iterator it = tasks.begin();
          it != tasks.end();
          ++it) {
-      graph->nodes.push_back(
-          internal::TaskGraph::Node(it->get(), 0u, leaf_tasks.size()));
+      graph->nodes.push_back(TaskGraph::Node(it->get(), 0u, leaf_tasks.size()));
 
       for (PerfTaskImpl::Vector::const_iterator leaf_it = leaf_tasks.begin();
            leaf_it != leaf_tasks.end();
            ++leaf_it) {
-        graph->edges.push_back(
-            internal::TaskGraph::Edge(leaf_it->get(), it->get()));
+        graph->edges.push_back(TaskGraph::Edge(leaf_it->get(), it->get()));
       }
 
       for (PerfTaskImpl::Vector::const_iterator top_level_it =
                top_level_tasks.begin();
            top_level_it != top_level_tasks.end();
            ++top_level_it) {
-        graph->edges.push_back(
-            internal::TaskGraph::Edge(it->get(), top_level_it->get()));
+        graph->edges.push_back(TaskGraph::Edge(it->get(), top_level_it->get()));
       }
     }
 
     for (PerfTaskImpl::Vector::const_iterator it = top_level_tasks.begin();
          it != top_level_tasks.end();
          ++it) {
-      graph->nodes.push_back(
-          internal::TaskGraph::Node(it->get(), 0u, tasks.size()));
+      graph->nodes.push_back(TaskGraph::Node(it->get(), 0u, tasks.size()));
     }
   }
 
-  size_t CollectCompletedTasks(internal::Task::Vector* completed_tasks) {
+  size_t CollectCompletedTasks(Task::Vector* completed_tasks) {
     DCHECK(completed_tasks->empty());
     task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                               completed_tasks);
     return completed_tasks->size();
   }
 
-  scoped_ptr<internal::TaskGraphRunner> task_graph_runner_;
-  internal::NamespaceToken namespace_token_;
+  scoped_ptr<TaskGraphRunner> task_graph_runner_;
+  NamespaceToken namespace_token_;
   LapTimer timer_;
 };
 
diff --git a/cc/resources/task_graph_runner_unittest.cc b/cc/resources/task_graph_runner_unittest.cc
index b1faa42..1a6256c 100644
--- a/cc/resources/task_graph_runner_unittest.cc
+++ b/cc/resources/task_graph_runner_unittest.cc
@@ -19,12 +19,12 @@ const int kNamespaceCount = 3;
 
 class TaskGraphRunnerTestBase {
  public:
-  struct Task {
-    Task(int namespace_index,
-         unsigned id,
-         unsigned dependent_id,
-         unsigned dependent_count,
-         unsigned priority)
+  struct TaskInfo {
+    TaskInfo(int namespace_index,
+             unsigned id,
+             unsigned dependent_id,
+             unsigned dependent_count,
+             unsigned priority)
         : namespace_index(namespace_index),
           id(id),
           dependent_id(dependent_id),
@@ -38,8 +38,7 @@ class TaskGraphRunnerTestBase {
     unsigned priority;
   };
 
-  TaskGraphRunnerTestBase()
-      : task_graph_runner_(new internal::TaskGraphRunner) {}
+  TaskGraphRunnerTestBase() : task_graph_runner_(new TaskGraphRunner) {}
 
   void ResetIds(int namespace_index) {
     run_task_ids_[namespace_index].clear();
@@ -50,10 +49,10 @@ class TaskGraphRunnerTestBase {
     task_graph_runner_->WaitForTasksToFinishRunning(
         namespace_token_[namespace_index]);
 
-    internal::Task::Vector completed_tasks;
+    Task::Vector completed_tasks;
     task_graph_runner_->CollectCompletedTasks(namespace_token_[namespace_index],
                                               &completed_tasks);
-    for (internal::Task::Vector::const_iterator it = completed_tasks.begin();
+    for (Task::Vector::const_iterator it = completed_tasks.begin();
          it != completed_tasks.end();
          ++it) {
       FakeTaskImpl* task = static_cast<FakeTaskImpl*>(it->get());
@@ -78,26 +77,26 @@ class TaskGraphRunnerTestBase {
     return on_task_completed_ids_[namespace_index];
   }
 
-  void ScheduleTasks(int namespace_index, const std::vector<Task>& tasks) {
-    internal::Task::Vector new_tasks;
-    internal::Task::Vector new_dependents;
-    internal::TaskGraph new_graph;
+  void ScheduleTasks(int namespace_index, const std::vector<TaskInfo>& tasks) {
+    Task::Vector new_tasks;
+    Task::Vector new_dependents;
+    TaskGraph new_graph;
 
-    for (std::vector<Task>::const_iterator it = tasks.begin();
+    for (std::vector<TaskInfo>::const_iterator it = tasks.begin();
          it != tasks.end();
          ++it) {
       scoped_refptr<FakeTaskImpl> new_task(
           new FakeTaskImpl(this, it->namespace_index, it->id));
       new_graph.nodes.push_back(
-          internal::TaskGraph::Node(new_task.get(), it->priority, 0u));
+          TaskGraph::Node(new_task.get(), it->priority, 0u));
       for (unsigned i = 0; i < it->dependent_count; ++i) {
         scoped_refptr<FakeDependentTaskImpl> new_dependent_task(
             new FakeDependentTaskImpl(
                 this, it->namespace_index, it->dependent_id));
-        new_graph.nodes.push_back(internal::TaskGraph::Node(
-            new_dependent_task.get(), it->priority, 1u));
-        new_graph.edges.push_back(internal::TaskGraph::Edge(
-            new_task.get(), new_dependent_task.get()));
+        new_graph.nodes.push_back(
+            TaskGraph::Node(new_dependent_task.get(), it->priority, 1u));
+        new_graph.edges.push_back(
+            TaskGraph::Edge(new_task.get(), new_dependent_task.get()));
 
         new_dependents.push_back(new_dependent_task.get());
       }
@@ -113,12 +112,12 @@ class TaskGraphRunnerTestBase {
   }
 
  protected:
-  class FakeTaskImpl : public internal::Task {
+  class FakeTaskImpl : public Task {
    public:
     FakeTaskImpl(TaskGraphRunnerTestBase* test, int namespace_index, int id)
         : test_(test), namespace_index_(namespace_index), id_(id) {}
 
-    // Overridden from internal::Task:
+    // Overridden from Task:
     virtual void RunOnWorkerThread() OVERRIDE {
       test_->RunTaskOnWorkerThread(namespace_index_, id_);
     }
@@ -154,10 +153,10 @@ class TaskGraphRunnerTestBase {
     DISALLOW_COPY_AND_ASSIGN(FakeDependentTaskImpl);
   };
 
-  scoped_ptr<internal::TaskGraphRunner> task_graph_runner_;
-  internal::NamespaceToken namespace_token_[kNamespaceCount];
-  internal::Task::Vector tasks_[kNamespaceCount];
-  internal::Task::Vector dependents_[kNamespaceCount];
+  scoped_ptr<TaskGraphRunner> task_graph_runner_;
+  NamespaceToken namespace_token_[kNamespaceCount];
+  Task::Vector tasks_[kNamespaceCount];
+  Task::Vector dependents_[kNamespaceCount];
   std::vector<unsigned> run_task_ids_[kNamespaceCount];
   base::Lock run_task_ids_lock_;
   std::vector<unsigned> on_task_completed_ids_[kNamespaceCount];
@@ -200,7 +199,7 @@ TEST_P(TaskGraphRunnerTest, Basic) {
     EXPECT_EQ(0u, run_task_ids(i).size());
     EXPECT_EQ(0u, on_task_completed_ids(i).size());
 
-    ScheduleTasks(i, std::vector<Task>(1, Task(i, 0u, 0u, 0u, 0u)));
+    ScheduleTasks(i, std::vector<TaskInfo>(1, TaskInfo(i, 0u, 0u, 0u, 0u)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
@@ -211,7 +210,7 @@ TEST_P(TaskGraphRunnerTest, Basic) {
   }
 
   for (int i = 0; i < kNamespaceCount; ++i)
-    ScheduleTasks(i, std::vector<Task>(1, Task(i, 0u, 0u, 1u, 0u)));
+    ScheduleTasks(i, std::vector<TaskInfo>(1, TaskInfo(i, 0u, 0u, 1u, 0u)));
 
   for (int i = 0; i < kNamespaceCount; ++i) {
     RunAllTasks(i);
@@ -221,7 +220,7 @@ TEST_P(TaskGraphRunnerTest, Basic) {
   }
 
   for (int i = 0; i < kNamespaceCount; ++i)
-    ScheduleTasks(i, std::vector<Task>(1, Task(i, 0u, 0u, 2u, 0u)));
+    ScheduleTasks(i, std::vector<TaskInfo>(1, TaskInfo(i, 0u, 0u, 2u, 0u)));
 
   for (int i = 0; i < kNamespaceCount; ++i) {
     RunAllTasks(i);
@@ -234,12 +233,12 @@ TEST_P(TaskGraphRunnerTest, Basic) {
 TEST_P(TaskGraphRunnerTest, Dependencies) {
   for (int i = 0; i < kNamespaceCount; ++i) {
     ScheduleTasks(i,
-                  std::vector<Task>(1,
-                                    Task(i,
-                                         0u,
-                                         1u,
-                                         1u,  // 1 dependent
-                                         0u)));
+                  std::vector<TaskInfo>(1,
+                                        TaskInfo(i,
+                                                 0u,
+                                                 1u,
+                                                 1u,  // 1 dependent
+                                                 0u)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
@@ -255,12 +254,12 @@ TEST_P(TaskGraphRunnerTest, Dependencies) {
 
   for (int i = 0; i < kNamespaceCount; ++i) {
     ScheduleTasks(i,
-                  std::vector<Task>(1,
-                                    Task(i,
-                                         2u,
-                                         3u,
-                                         2u,  // 2 dependents
-                                         0u)));
+                  std::vector<TaskInfo>(1,
+                                        TaskInfo(i,
+                                                 2u,
+                                                 3u,
+                                                 2u,  // 2 dependents
+                                                 0u)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
@@ -307,10 +306,10 @@ class TaskGraphRunnerSingleThreadTest
 
 TEST_F(TaskGraphRunnerSingleThreadTest, Priority) {
   for (int i = 0; i < kNamespaceCount; ++i) {
-    Task tasks[] = {Task(i, 0u, 2u, 1u, 1u),  // Priority 1
-                    Task(i, 1u, 3u, 1u, 0u)   // Priority 0
+    TaskInfo tasks[] = {TaskInfo(i, 0u, 2u, 1u, 1u),  // Priority 1
+                        TaskInfo(i, 1u, 3u, 1u, 0u)   // Priority 0
     };
-    ScheduleTasks(i, std::vector<Task>(tasks, tasks + arraysize(tasks)));
+    ScheduleTasks(i, std::vector<TaskInfo>(tasks, tasks + arraysize(tasks)));
   }
 
   for (int i = 0; i < kNamespaceCount; ++i) {
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 4de7ba2..963808e 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -45,7 +45,7 @@ class DisableLCDTextFilter : public SkDrawFilter {
   }
 };
 
-class RasterTaskImpl : public internal::RasterTask {
+class RasterTaskImpl : public RasterTask {
  public:
   RasterTaskImpl(
       const Resource* resource,
@@ -60,8 +60,8 @@ class RasterTaskImpl : public internal::RasterTask {
       bool analyze_picture,
       RenderingStatsInstrumentation* rendering_stats,
       const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply,
-      internal::ImageDecodeTask::Vector* dependencies)
-      : internal::RasterTask(resource, dependencies),
+      ImageDecodeTask::Vector* dependencies)
+      : RasterTask(resource, dependencies),
         picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
@@ -75,7 +75,7 @@ class RasterTaskImpl : public internal::RasterTask {
         reply_(reply),
         canvas_(NULL) {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
 
@@ -86,9 +86,8 @@ class RasterTaskImpl : public internal::RasterTask {
     }
   }
 
-  // Overridden from internal::RasterizerTask:
-  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {
+  // Overridden from RasterizerTask:
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
     DCHECK(!canvas_);
     canvas_ = client->AcquireCanvasForRaster(this);
   }
@@ -97,8 +96,7 @@ class RasterTaskImpl : public internal::RasterTask {
     if (canvas_)
       AnalyzeAndRaster(picture_pile_);
   }
-  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
     canvas_ = NULL;
     client->ReleaseCanvasForRaster(this);
   }
@@ -222,7 +220,7 @@ class RasterTaskImpl : public internal::RasterTask {
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
-class ImageDecodeTaskImpl : public internal::ImageDecodeTask {
+class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(SkPixelRef* pixel_ref,
                       int layer_id,
@@ -233,21 +231,19 @@ class ImageDecodeTaskImpl : public internal::ImageDecodeTask {
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
-  // Overridden from internal::Task:
+  // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     TRACE_EVENT0("cc", "ImageDecodeTaskImpl::RunOnWorkerThread");
     Decode();
   }
 
-  // Overridden from internal::RasterizerTask:
-  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {}
+  // Overridden from RasterizerTask:
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
   virtual void RunOnOriginThread() OVERRIDE {
     TRACE_EVENT0("cc", "ImageDecodeTaskImpl::RunOnOriginThread");
     Decode();
   }
-  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
-      OVERRIDE {}
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
   virtual void RunReplyOnOriginThread() OVERRIDE {
     reply_.Run(!HasFinishedRunning());
   }
@@ -1085,7 +1081,7 @@ void TileManager::ScheduleTasks(
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
 }
 
-scoped_refptr<internal::ImageDecodeTask> TileManager::CreateImageDecodeTask(
+scoped_refptr<ImageDecodeTask> TileManager::CreateImageDecodeTask(
     Tile* tile,
     SkPixelRef* pixel_ref) {
   return make_scoped_refptr(new ImageDecodeTaskImpl(
@@ -1098,7 +1094,7 @@ scoped_refptr<internal::ImageDecodeTask> TileManager::CreateImageDecodeTask(
                  base::Unretained(pixel_ref))));
 }
 
-scoped_refptr<internal::RasterTask> TileManager::CreateRasterTask(Tile* tile) {
+scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ScopedResource> resource =
@@ -1106,7 +1102,7 @@ scoped_refptr<internal::RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   const ScopedResource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
-  internal::ImageDecodeTask::Vector decode_tasks;
+  ImageDecodeTask::Vector decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   for (PicturePileImpl::PixelRefIterator iter(
            tile->content_rect(), tile->contents_scale(), tile->picture_pile());
@@ -1123,7 +1119,7 @@ scoped_refptr<internal::RasterTask> TileManager::CreateRasterTask(Tile* tile) {
     }
 
     // Create and append new image decode task for this pixel ref.
-    scoped_refptr<internal::ImageDecodeTask> decode_task =
+    scoped_refptr<ImageDecodeTask> decode_task =
         CreateImageDecodeTask(tile, pixel_ref);
     decode_tasks.push_back(decode_task);
     existing_pixel_refs[id] = decode_task;
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index f0fc0be..6c71152 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -282,10 +282,9 @@ class CC_EXPORT TileManager : public RasterizerClient,
   void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
   void FreeUnusedResourcesForTile(Tile* tile);
-  scoped_refptr<internal::ImageDecodeTask> CreateImageDecodeTask(
-      Tile* tile,
-      SkPixelRef* pixel_ref);
-  scoped_refptr<internal::RasterTask> CreateRasterTask(Tile* tile);
+  scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile,
+                                                       SkPixelRef* pixel_ref);
+  scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
   scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
   void UpdatePrioritizedTileSetIfNeeded();
 
@@ -318,7 +317,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
   bool did_initialize_visible_tile_;
   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
 
-  typedef base::hash_map<uint32_t, scoped_refptr<internal::ImageDecodeTask> >
+  typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> >
       PixelRefTaskMap;
   typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
   LayerPixelRefTaskMap image_decode_tasks_;
@@ -337,7 +336,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
   // Queues used when scheduling raster tasks.
   RasterTaskQueue raster_queue_[NUM_RASTERIZER_TYPES];
 
-  std::vector<scoped_refptr<internal::RasterTask> > orphan_raster_tasks_;
+  std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_;
 
   std::vector<PictureLayerImpl*> layers_;
 
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index 4fbf704..3b86035 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -14,8 +14,7 @@ namespace cc {
 
 namespace {
 
-class FakeRasterizerImpl : public Rasterizer,
-                           public internal::RasterizerTaskClient {
+class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
  public:
   // Overridden from Rasterizer:
   virtual void SetClient(RasterizerClient* client) OVERRIDE {}
@@ -25,7 +24,7 @@ class FakeRasterizerImpl : public Rasterizer,
              queue->items.begin();
          it != queue->items.end();
          ++it) {
-      internal::RasterTask* task = it->task;
+      RasterTask* task = it->task;
 
       task->WillSchedule();
       task->ScheduleOnOriginThread(this);
@@ -35,10 +34,10 @@ class FakeRasterizerImpl : public Rasterizer,
     }
   }
   virtual void CheckForCompletedTasks() OVERRIDE {
-    for (internal::RasterTask::Vector::iterator it = completed_tasks_.begin();
+    for (RasterTask::Vector::iterator it = completed_tasks_.begin();
          it != completed_tasks_.end();
          ++it) {
-      internal::RasterTask* task = it->get();
+      RasterTask* task = it->get();
 
       task->WillComplete();
       task->CompleteOnOriginThread(this);
@@ -49,15 +48,14 @@ class FakeRasterizerImpl : public Rasterizer,
     completed_tasks_.clear();
   }
 
-  // Overridden from internal::RasterizerTaskClient:
-  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterTask* task)
-      OVERRIDE {
+  // Overridden from RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(RasterTask* task) OVERRIDE {
     return NULL;
   }
-  virtual void ReleaseCanvasForRaster(internal::RasterTask* task) OVERRIDE {}
+  virtual void ReleaseCanvasForRaster(RasterTask* task) OVERRIDE {}
 
  private:
-  internal::RasterTask::Vector completed_tasks_;
+  RasterTask::Vector completed_tasks_;
 };
 base::LazyInstance<FakeRasterizerImpl> g_fake_rasterizer =
     LAZY_INSTANCE_INITIALIZER;