Eliminate ash::internal namespace

ash/desktop_background/desktop_background_controller.cc

 // Copyright (c) 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.
 
 #include "ash/desktop_background/desktop_background_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/desktop_background/desktop_background_view.h"
 #include "ash/desktop_background/desktop_background_widget_controller.h"
@@ skipping 15 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/widget/widget.h"
 
-using ash::internal::DesktopBackgroundWidgetController;
 using content::BrowserThread;
 
 namespace ash {
 namespace {
 
 // How long to wait reloading the wallpaper after the max display has
 // changed?
 const int kWallpaperReloadDelayMs = 2000;
 
 }  // namespace
@@ skipping 316 matching lines @@
                     OnWallpaperDataChanged());
 
   SetDesktopBackgroundImageMode();
 
   DCHECK(loader.get() == default_wallpaper_loader_.get());
   default_wallpaper_loader_ = NULL;
 }
 
 void DesktopBackgroundController::InstallDesktopController(
     aura::Window* root_window) {
-  internal::DesktopBackgroundWidgetController* component = NULL;
+  DesktopBackgroundWidgetController* component = NULL;
   int container_id = GetBackgroundContainerId(locked_);
 
   switch (desktop_background_mode_) {
     case BACKGROUND_IMAGE: {
-      views::Widget* widget = internal::CreateDesktopBackground(root_window,
-                                                                container_id);
-      component = new internal::DesktopBackgroundWidgetController(widget);
+      views::Widget* widget =
+          CreateDesktopBackground(root_window, container_id);
+      component = new DesktopBackgroundWidgetController(widget);
       break;
     }
     case BACKGROUND_NONE:
       NOTREACHED();
       return;
   }
-  internal::GetRootWindowController(root_window)->
-      SetAnimatingWallpaperController(
-          new internal::AnimatingDesktopController(component));
+  GetRootWindowController(root_window)->SetAnimatingWallpaperController(
+      new AnimatingDesktopController(component));
 
-  component->StartAnimating(internal::GetRootWindowController(root_window));
+  component->StartAnimating(GetRootWindowController(root_window));
 }
 
 void DesktopBackgroundController::InstallDesktopControllerForAllWindows() {
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     InstallDesktopController(*iter);
   }
   current_max_display_size_ = GetMaxDisplaySizeInNative();
 }
 
 bool DesktopBackgroundController::ReparentBackgroundWidgets(int src_container,
                                                             int dst_container) {
   bool moved = false;
   Shell::RootWindowControllerList controllers =
       Shell::GetAllRootWindowControllers();
   for (Shell::RootWindowControllerList::iterator iter = controllers.begin();
     iter != controllers.end(); ++iter) {
-    internal::RootWindowController* root_window_controller = *iter;
+    RootWindowController* root_window_controller = *iter;
     // In the steady state (no animation playing) the background widget
     // controller exists in the RootWindowController.
     DesktopBackgroundWidgetController* desktop_controller =
         root_window_controller->wallpaper_controller();
     if (desktop_controller) {
       moved |= desktop_controller->Reparent(
           root_window_controller->root_window(),
           src_container,
           dst_container);
     }
@@ skipping 11 matching lines @@
       moved |= animating_controller->Reparent(
           root_window_controller->root_window(),
           src_container,
           dst_container);
     }
   }
   return moved;
 }
 
 int DesktopBackgroundController::GetBackgroundContainerId(bool locked) {
-  return locked ? internal::kShellWindowId_LockScreenBackgroundContainer :
-                  internal::kShellWindowId_DesktopBackgroundContainer;
+  return locked ? kShellWindowId_LockScreenBackgroundContainer
+                : kShellWindowId_DesktopBackgroundContainer;
 }
 
 void DesktopBackgroundController::UpdateWallpaper() {
   current_wallpaper_.reset(NULL);
   current_default_wallpaper_path_ = base::FilePath();
   current_default_wallpaper_resource_id_ = -1;
   ash::Shell::GetInstance()->user_wallpaper_delegate()->
       UpdateWallpaper(true /* clear cache */);
 }
 
 // static
 gfx::Size DesktopBackgroundController::GetMaxDisplaySizeInNative() {
   int width = 0;
   int height = 0;
   std::vector<gfx::Display> displays = Shell::GetScreen()->GetAllDisplays();
-  internal::DisplayManager* display_manager =
-      Shell::GetInstance()->display_manager();
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 
   for (std::vector<gfx::Display>::iterator iter = displays.begin();
        iter != displays.end(); ++iter) {
     // Don't use size_in_pixel because we want to use the native pixel size.
     gfx::Size size_in_pixel =
         display_manager->GetDisplayInfo(iter->id()).bounds_in_native().size();
     if (iter->rotation() == gfx::Display::ROTATE_90 ||
         iter->rotation() == gfx::Display::ROTATE_270) {
       size_in_pixel = gfx::Size(size_in_pixel.height(), size_in_pixel.width());
     }
     width = std::max(size_in_pixel.width(), width);
     height = std::max(size_in_pixel.height(), height);
   }
   return gfx::Size(width, height);
 }
 
 }  // namespace ash