Move AppWindow to extensions

extensions/browser/app_window/app_window.cc

 // Copyright 2014 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 "apps/app_window.h"
+#include "extensions/browser/app_window/app_window.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
-#include "apps/app_window_registry.h"
-#include "apps/ui/apps_client.h"
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/media_stream_request.h"
 #include "extensions/browser/app_window/app_delegate.h"
 #include "extensions/browser/app_window/app_web_contents_helper.h"
 #include "extensions/browser/app_window/app_window_geometry_cache.h"
+#include "extensions/browser/app_window/app_window_registry.h"
+#include "extensions/browser/app_window/apps_client.h"
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/browser/app_window/size_constraints.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/suggest_permission_util.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/draggable_region.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/screen.h"
 
 #if !defined(OS_MACOSX)
 #include "base/prefs/pref_service.h"
 #include "extensions/browser/pref_names.h"
 #endif
 
 using content::BrowserContext;
 using content::ConsoleMessageLevel;
 using content::WebContents;
-using extensions::APIPermission;
-using extensions::NativeAppWindow;
 using web_modal::WebContentsModalDialogHost;
 using web_modal::WebContentsModalDialogManager;
 
-namespace apps {
+namespace extensions {
 
 namespace {
 
 const int kDefaultWidth = 512;
 const int kDefaultHeight = 384;
 
 void SetConstraintProperty(const std::string& name,
                            int value,
                            base::DictionaryValue* bounds_properties) {
-  if (value != extensions::SizeConstraints::kUnboundedSize)
+  if (value != SizeConstraints::kUnboundedSize)
     bounds_properties->SetInteger(name, value);
   else
     bounds_properties->Set(name, base::Value::CreateNullValue());
 }
 
 void SetBoundsProperties(const gfx::Rect& bounds,
                          const gfx::Size& min_size,
                          const gfx::Size& max_size,
                          const std::string& bounds_name,
                          base::DictionaryValue* window_properties) {
@@ skipping 94 matching lines @@
   if (content_spec.bounds.width() > 0) {
     combined_bounds.set_width(
         content_spec.bounds.width() + frame_insets.width());
   }
   if (content_spec.bounds.height() > 0) {
     combined_bounds.set_height(
         content_spec.bounds.height() + frame_insets.height());
   }
 
   // Constrain the bounds.
-  extensions::SizeConstraints constraints(
+  SizeConstraints constraints(
       GetCombinedWindowConstraints(
           window_spec.minimum_size, content_spec.minimum_size, frame_insets),
       GetCombinedWindowConstraints(
           window_spec.maximum_size, content_spec.maximum_size, frame_insets));
   combined_bounds.set_size(constraints.ClampSize(combined_bounds.size()));
 
   return combined_bounds;
 }
 
 gfx::Size AppWindow::CreateParams::GetContentMinimumSize(
@@ skipping 20 matching lines @@
 gfx::Size AppWindow::CreateParams::GetWindowMaximumSize(
     const gfx::Insets& frame_insets) const {
   return GetCombinedWindowConstraints(window_spec.maximum_size,
                                       content_spec.maximum_size,
                                       frame_insets);
 }
 
 // AppWindow
 
 AppWindow::AppWindow(BrowserContext* context,
-                     extensions::AppDelegate* app_delegate,
-                     const extensions::Extension* extension)
+                     AppDelegate* app_delegate,
+                     const Extension* extension)
     : browser_context_(context),
       extension_id_(extension->id()),
       window_type_(WINDOW_TYPE_DEFAULT),
       app_delegate_(app_delegate),
       image_loader_ptr_factory_(this),
       fullscreen_types_(FULLSCREEN_TYPE_NONE),
       show_on_first_paint_(false),
       first_paint_complete_(false),
       has_been_shown_(false),
       can_send_events_(false),
       is_hidden_(false),
       cached_always_on_top_(false),
       requested_alpha_enabled_(false) {
-  extensions::ExtensionsBrowserClient* client =
-      extensions::ExtensionsBrowserClient::Get();
+  ExtensionsBrowserClient* client = ExtensionsBrowserClient::Get();
   CHECK(!client->IsGuestSession(context) || context->IsOffTheRecord())
       << "Only off the record window may be opened in the guest mode.";
 }
 
 void AppWindow::Init(const GURL& url,
                      AppWindowContents* app_window_contents,
                      const CreateParams& params) {
   // Initialize the render interface and web contents
   app_window_contents_.reset(app_window_contents);
   app_window_contents_->Initialize(browser_context(), url);
   WebContents* web_contents = app_window_contents_->GetWebContents();
   if (CommandLine::ForCurrentProcess()->HasSwitch(
-          extensions::switches::kEnableAppsShowOnFirstPaint)) {
+          switches::kEnableAppsShowOnFirstPaint)) {
     content::WebContentsObserver::Observe(web_contents);
   }
   app_delegate_->InitWebContents(web_contents);
 
   WebContentsModalDialogManager::CreateForWebContents(web_contents);
 
   web_contents->SetDelegate(this);
   WebContentsModalDialogManager::FromWebContents(web_contents)
       ->SetDelegate(this);
-  extensions::SetViewType(web_contents, extensions::VIEW_TYPE_APP_WINDOW);
+  SetViewType(web_contents, VIEW_TYPE_APP_WINDOW);
 
   // Initialize the window
   CreateParams new_params = LoadDefaults(params);
   window_type_ = new_params.window_type;
   window_key_ = new_params.window_key;
 
   // Windows cannot be always-on-top in fullscreen mode for security reasons.
   cached_always_on_top_ = new_params.always_on_top;
   if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
     new_params.always_on_top = false;
 
   requested_alpha_enabled_ = new_params.alpha_enabled;
 
   AppsClient* apps_client = AppsClient::Get();
   native_app_window_.reset(
       apps_client->CreateNativeAppWindow(this, new_params));
 
-  helper_.reset(new extensions::AppWebContentsHelper(
+  helper_.reset(new AppWebContentsHelper(
       browser_context_, extension_id_, web_contents, app_delegate_.get()));
 
   popup_manager_.reset(
       new web_modal::PopupManager(GetWebContentsModalDialogHost()));
   popup_manager_->RegisterWith(web_contents);
 
   // Prevent the browser process from shutting down while this window exists.
   apps_client->IncrementKeepAliveCount();
   UpdateExtensionAppIcon();
   AppWindowRegistry::Get(browser_context_)->AddAppWindow(this);
@@ skipping 14 matching lines @@
     Maximize();
   else if (new_params.state == ui::SHOW_STATE_MINIMIZED)
     Minimize();
 
   OnNativeWindowChanged();
 
   // When the render view host is changed, the native window needs to know
   // about it in case it has any setup to do to make the renderer appear
   // properly. In particular, on Windows, the view's clickthrough region needs
   // to be set.
-  extensions::ExtensionsBrowserClient* client =
-      extensions::ExtensionsBrowserClient::Get();
+  ExtensionsBrowserClient* client = ExtensionsBrowserClient::Get();
   registrar_.Add(this,
-                 extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
+                 NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<content::BrowserContext>(
                      client->GetOriginalContext(browser_context_)));
   // Update the app menu if an ephemeral app becomes installed.
   registrar_.Add(
       this,
-      extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
+      NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
       content::Source<content::BrowserContext>(
           client->GetOriginalContext(browser_context_)));
 
   // Close when the browser process is exiting.
   app_delegate_->SetTerminatingCallback(
       base::Bind(&NativeAppWindow::Close,
                  base::Unretained(native_app_window_.get())));
 
   app_window_contents_->LoadContents(new_params.creator_process_id);
 
@@ skipping 43 matching lines @@
                                 disposition,
                                 initial_pos,
                                 user_gesture,
                                 was_blocked);
 }
 
 bool AppWindow::PreHandleKeyboardEvent(
     content::WebContents* source,
     const content::NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
-  const extensions::Extension* extension = GetExtension();
+  const Extension* extension = GetExtension();
   if (!extension)
     return false;
 
   // Here, we can handle a key event before the content gets it. When we are
   // fullscreen and it is not forced, we want to allow the user to leave
   // when ESC is pressed.
   // However, if the application has the "overrideEscFullscreen" permission, we
   // should let it override that behavior.
   // ::HandleKeyboardEvent() will only be called if the KeyEvent's default
   // action is not prevented.
@@ skipping 26 matching lines @@
 
 void AppWindow::RequestToLockMouse(WebContents* web_contents,
                                    bool user_gesture,
                                    bool last_unlocked_by_target) {
   DCHECK_EQ(AppWindow::web_contents(), web_contents);
   helper_->RequestToLockMouse();
 }
 
 bool AppWindow::PreHandleGestureEvent(WebContents* source,
                                       const blink::WebGestureEvent& event) {
-  return extensions::AppWebContentsHelper::ShouldSuppressGestureEvent(event);
+  return AppWebContentsHelper::ShouldSuppressGestureEvent(event);
 }
 
 void AppWindow::DidFirstVisuallyNonEmptyPaint() {
   first_paint_complete_ = true;
   if (show_on_first_paint_) {
     DCHECK(delayed_show_type_ == SHOW_ACTIVE ||
            delayed_show_type_ == SHOW_INACTIVE);
     Show(delayed_show_type_);
   }
 }
@@ skipping 25 matching lines @@
 }
 
 void AppWindow::OnNativeWindowActivated() {
   AppWindowRegistry::Get(browser_context_)->AppWindowActivated(this);
 }
 
 content::WebContents* AppWindow::web_contents() const {
   return app_window_contents_->GetWebContents();
 }
 
-const extensions::Extension* AppWindow::GetExtension() const {
-  return extensions::ExtensionRegistry::Get(browser_context_)
+const Extension* AppWindow::GetExtension() const {
+  return ExtensionRegistry::Get(browser_context_)
       ->enabled_extensions()
       .GetByID(extension_id_);
 }
 
 NativeAppWindow* AppWindow::GetBaseWindow() { return native_app_window_.get(); }
 
 gfx::NativeWindow AppWindow::GetNativeWindow() {
   return GetBaseWindow()->GetNativeWindow();
 }
 
 gfx::Rect AppWindow::GetClientBounds() const {
   gfx::Rect bounds = native_app_window_->GetBounds();
   bounds.Inset(native_app_window_->GetFrameInsets());
   return bounds;
 }
 
 base::string16 AppWindow::GetTitle() const {
-  const extensions::Extension* extension = GetExtension();
+  const Extension* extension = GetExtension();
   if (!extension)
     return base::string16();
 
   // WebContents::GetTitle() will return the page's URL if there's no <title>
   // specified. However, we'd prefer to show the name of the extension in that
   // case, so we directly inspect the NavigationEntry's title.
   base::string16 title;
   if (!web_contents() || !web_contents()->GetController().GetActiveEntry() ||
       web_contents()->GetController().GetActiveEntry()->GetTitle().empty()) {
     title = base::UTF8ToUTF16(extension->name());
@@ skipping 44 matching lines @@
   badge_icon_image_.reset();
   badge_icon_url_ = GURL();
   UpdateBadgeIcon(gfx::Image());
 }
 
 void AppWindow::UpdateShape(scoped_ptr<SkRegion> region) {
   native_app_window_->UpdateShape(region.Pass());
 }
 
 void AppWindow::UpdateDraggableRegions(
-    const std::vector<extensions::DraggableRegion>& regions) {
+    const std::vector<DraggableRegion>& regions) {
   native_app_window_->UpdateDraggableRegions(regions);
 }
 
 void AppWindow::UpdateAppIcon(const gfx::Image& image) {
   if (image.IsEmpty())
     return;
   app_icon_ = image;
   native_app_window_->UpdateWindowIcon();
   AppWindowRegistry::Get(browser_context_)->AppWindowIconChanged(this);
 }
 
 void AppWindow::SetFullscreen(FullscreenType type, bool enable) {
   DCHECK_NE(FULLSCREEN_TYPE_NONE, type);
 
   if (enable) {
 #if !defined(OS_MACOSX)
     // Do not enter fullscreen mode if disallowed by pref.
     // TODO(bartfab): Add a test once it becomes possible to simulate a user
     // gesture. http://crbug.com/174178
     if (type != FULLSCREEN_TYPE_FORCED) {
       PrefService* prefs =
-          extensions::ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
+          ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
               browser_context());
-      if (!prefs->GetBoolean(extensions::pref_names::kAppFullscreenAllowed))
+      if (!prefs->GetBoolean(pref_names::kAppFullscreenAllowed))
         return;
     }
 #endif
     fullscreen_types_ |= type;
   } else {
     fullscreen_types_ &= ~type;
   }
   SetNativeWindowFullscreen();
 }
 
@@ skipping 29 matching lines @@
 void AppWindow::OSFullscreen() {
   SetFullscreen(FULLSCREEN_TYPE_OS, true);
 }
 
 void AppWindow::ForcedFullscreen() {
   SetFullscreen(FULLSCREEN_TYPE_FORCED, true);
 }
 
 void AppWindow::SetContentSizeConstraints(const gfx::Size& min_size,
                                           const gfx::Size& max_size) {
-  extensions::SizeConstraints constraints(min_size, max_size);
+  SizeConstraints constraints(min_size, max_size);
   native_app_window_->SetContentSizeConstraints(constraints.GetMinimumSize(),
                                                 constraints.GetMaximumSize());
 
   gfx::Rect bounds = GetClientBounds();
   gfx::Size constrained_size = constraints.ClampSize(bounds.size());
   if (bounds.size() != constrained_size) {
     bounds.set_size(constrained_size);
     bounds.Inset(-native_app_window_->GetFrameInsets());
     native_app_window_->SetBounds(bounds);
   }
   OnNativeWindowChanged();
 }
 
 void AppWindow::Show(ShowType show_type) {
   is_hidden_ = false;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
-          extensions::switches::kEnableAppsShowOnFirstPaint)) {
+          switches::kEnableAppsShowOnFirstPaint)) {
     show_on_first_paint_ = true;
 
     if (!first_paint_complete_) {
       delayed_show_type_ = show_type;
       return;
     }
   }
 
   switch (show_type) {
     case SHOW_ACTIVE:
@@ skipping 70 matching lines @@
   gfx::Size content_min_size = native_app_window_->GetContentMinimumSize();
   gfx::Size content_max_size = native_app_window_->GetContentMaximumSize();
   SetBoundsProperties(content_bounds,
                       content_min_size,
                       content_max_size,
                       "innerBounds",
                       properties);
 
   gfx::Insets frame_insets = native_app_window_->GetFrameInsets();
   gfx::Rect frame_bounds = native_app_window_->GetBounds();
-  gfx::Size frame_min_size = extensions::SizeConstraints::AddFrameToConstraints(
+  gfx::Size frame_min_size = SizeConstraints::AddFrameToConstraints(
       content_min_size, frame_insets);
-  gfx::Size frame_max_size = extensions::SizeConstraints::AddFrameToConstraints(
+  gfx::Size frame_max_size = SizeConstraints::AddFrameToConstraints(
       content_max_size, frame_insets);
   SetBoundsProperties(frame_bounds,
                       frame_min_size,
                       frame_max_size,
                       "outerBounds",
                       properties);
 }
 
 //------------------------------------------------------------------------------
 // Private methods
@@ skipping 24 matching lines @@
   }
   const SkBitmap& largest = bitmaps[largest_index];
   if (image_url == app_icon_url_) {
     UpdateAppIcon(gfx::Image::CreateFrom1xBitmap(largest));
     return;
   }
 
   UpdateBadgeIcon(gfx::Image::CreateFrom1xBitmap(largest));
 }
 
-void AppWindow::OnExtensionIconImageChanged(extensions::IconImage* image) {
+void AppWindow::OnExtensionIconImageChanged(IconImage* image) {
   DCHECK_EQ(app_icon_image_.get(), image);
 
   UpdateAppIcon(gfx::Image(app_icon_image_->image_skia()));
 }
 
 void AppWindow::UpdateExtensionAppIcon() {
   // Avoid using any previous app icons were being downloaded.
   image_loader_ptr_factory_.InvalidateWeakPtrs();
 
-  const extensions::Extension* extension = GetExtension();
+  const Extension* extension = GetExtension();
   if (!extension)
     return;
 
-  app_icon_image_.reset(
-      new extensions::IconImage(browser_context(),
-                                extension,
-                                extensions::IconsInfo::GetIcons(extension),
-                                app_delegate_->PreferredIconSize(),
-                                app_delegate_->GetAppDefaultIcon(),
-                                this));
+  app_icon_image_.reset(new IconImage(browser_context(),
+                                      extension,
+                                      IconsInfo::GetIcons(extension),
+                                      app_delegate_->PreferredIconSize(),
+                                      app_delegate_->GetAppDefaultIcon(),
+                                      this));
 
   // Triggers actual image loading with 1x resources. The 2x resource will
   // be handled by IconImage class when requested.
   app_icon_image_->image_skia().GetRepresentation(1.0f);
 }
 
 void AppWindow::SetNativeWindowFullscreen() {
   native_app_window_->SetFullscreen(fullscreen_types_);
 
   if (cached_always_on_top_)
@@ skipping 36 matching lines @@
     // When exiting fullscreen and moving away from the taskbar, reinstate
     // always-on-top.
     native_app_window_->SetAlwaysOnTop(true);
   }
 }
 
 void AppWindow::SendOnWindowShownIfShown() {
   if (!can_send_events_ || !has_been_shown_)
     return;
 
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(::switches::kTestType)) {
     app_window_contents_->DispatchWindowShownForTests();
   }
 }
 
 void AppWindow::CloseContents(WebContents* contents) {
   native_app_window_->Close();
 }
 
 bool AppWindow::ShouldSuppressDialogs() { return true; }
 
@@ skipping 26 matching lines @@
 void AppWindow::NavigationStateChanged(const content::WebContents* source,
                                        content::InvalidateTypes changed_flags) {
   if (changed_flags & content::INVALIDATE_TYPE_TITLE)
     native_app_window_->UpdateWindowTitle();
   else if (changed_flags & content::INVALIDATE_TYPE_TAB)
     native_app_window_->UpdateWindowIcon();
 }
 
 void AppWindow::ToggleFullscreenModeForTab(content::WebContents* source,
                                            bool enter_fullscreen) {
-  const extensions::Extension* extension = GetExtension();
+  const Extension* extension = GetExtension();
   if (!extension)
     return;
 
   if (!IsExtensionWithPermissionOrSuggestInConsole(
           APIPermission::kFullscreen, extension, source->GetRenderViewHost())) {
     return;
   }
 
   SetFullscreen(FULLSCREEN_TYPE_HTML_API, enter_fullscreen);
 }
 
 bool AppWindow::IsFullscreenForTabOrPending(const content::WebContents* source)
     const {
   return IsHtmlApiFullscreen();
 }
 
 void AppWindow::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   switch (type) {
-    case extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
-      const extensions::Extension* unloaded_extension =
-          content::Details<extensions::UnloadedExtensionInfo>(details)
-              ->extension;
+    case NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
+      const Extension* unloaded_extension =
+          content::Details<UnloadedExtensionInfo>(details)->extension;
       if (extension_id_ == unloaded_extension->id())
         native_app_window_->Close();
       break;
     }
-    case extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED: {
-      const extensions::Extension* installed_extension =
-          content::Details<const extensions::InstalledExtensionInfo>(details)
-              ->extension;
+    case NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED: {
+      const Extension* installed_extension =
+          content::Details<const InstalledExtensionInfo>(details)->extension;
       DCHECK(installed_extension);
       if (installed_extension->id() == extension_id())
         native_app_window_->UpdateShelfMenu();
       break;
     }
     default:
       NOTREACHED() << "Received unexpected notification";
   }
 }
 
 void AppWindow::SetWebContentsBlocked(content::WebContents* web_contents,
                                       bool blocked) {
   app_delegate_->SetWebContentsBlocked(web_contents, blocked);
 }
 
 bool AppWindow::IsWebContentsVisible(content::WebContents* web_contents) {
   return app_delegate_->IsWebContentsVisible(web_contents);
 }
 
 WebContentsModalDialogHost* AppWindow::GetWebContentsModalDialogHost() {
   return native_app_window_.get();
 }
 
 void AppWindow::SaveWindowPosition() {
   if (window_key_.empty())
     return;
   if (!native_app_window_)
     return;
 
-  extensions::AppWindowGeometryCache* cache =
-      extensions::AppWindowGeometryCache::Get(browser_context());
+  AppWindowGeometryCache* cache =
+      AppWindowGeometryCache::Get(browser_context());
 
   gfx::Rect bounds = native_app_window_->GetRestoredBounds();
   gfx::Rect screen_bounds =
       gfx::Screen::GetNativeScreen()->GetDisplayMatching(bounds).work_area();
   ui::WindowShowState window_state = native_app_window_->GetRestoredState();
   cache->SaveGeometry(
       extension_id(), window_key_, bounds, screen_bounds, window_state);
 }
 
 void AppWindow::AdjustBoundsToBeVisibleOnScreen(
@@ skipping 36 matching lines @@
   if (params.content_spec.bounds.height() == 0 &&
       params.window_spec.bounds.height() == 0) {
     params.content_spec.bounds.set_height(kDefaultHeight);
   }
 
   // If left and top are left undefined, the native app window will center
   // the window on the main screen in a platform-defined manner.
 
   // Load cached state if it exists.
   if (!params.window_key.empty()) {
-    extensions::AppWindowGeometryCache* cache =
-        extensions::AppWindowGeometryCache::Get(browser_context());
+    AppWindowGeometryCache* cache =
+        AppWindowGeometryCache::Get(browser_context());
 
     gfx::Rect cached_bounds;
     gfx::Rect cached_screen_bounds;
     ui::WindowShowState cached_state = ui::SHOW_STATE_DEFAULT;
     if (cache->GetGeometry(extension_id(),
                            params.window_key,
                            &cached_bounds,
                            &cached_screen_bounds,
                            &cached_state)) {
       // App window has cached screen bounds, make sure it fits on screen in
       // case the screen resolution changed.
       gfx::Screen* screen = gfx::Screen::GetNativeScreen();
       gfx::Display display = screen->GetDisplayMatching(cached_bounds);
       gfx::Rect current_screen_bounds = display.work_area();
-      extensions::SizeConstraints constraints(
-          params.GetWindowMinimumSize(gfx::Insets()),
-          params.GetWindowMaximumSize(gfx::Insets()));
+      SizeConstraints constraints(params.GetWindowMinimumSize(gfx::Insets()),
+                                  params.GetWindowMaximumSize(gfx::Insets()));
       AdjustBoundsToBeVisibleOnScreen(cached_bounds,
                                       cached_screen_bounds,
                                       current_screen_bounds,
                                       constraints.GetMinimumSize(),
                                       &params.window_spec.bounds);
       params.state = cached_state;
 
       // Since we are restoring a cached state, reset the content bounds spec to
       // ensure it is not used.
       params.content_spec.ResetBounds();
     }
   }
 
   return params;
 }
 
 // static
 SkRegion* AppWindow::RawDraggableRegionsToSkRegion(
-    const std::vector<extensions::DraggableRegion>& regions) {
+    const std::vector<DraggableRegion>& regions) {
   SkRegion* sk_region = new SkRegion;
-  for (std::vector<extensions::DraggableRegion>::const_iterator iter =
-           regions.begin();
+  for (std::vector<DraggableRegion>::const_iterator iter = regions.begin();
        iter != regions.end();
        ++iter) {
-    const extensions::DraggableRegion& region = *iter;
+    const DraggableRegion& region = *iter;
     sk_region->op(
         region.bounds.x(),
         region.bounds.y(),
         region.bounds.right(),
         region.bounds.bottom(),
         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
   return sk_region;
 }
 
-}  // namespace apps
+}  // namespace extensions