Extract NativeAppWindow from src/extensions

extensions/browser/api/app_window/app_window_api.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 "extensions/browser/api/app_window/app_window_api.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_client.h"
 #include "extensions/browser/app_window/app_window_contents.h"
 #include "extensions/browser/app_window/app_window_registry.h"
-#include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/image_util.h"
 #include "extensions/common/api/app_window.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/rect.h"
@@ skipping 57 matching lines @@
     subst.push_back(property_name);
     *error = ReplaceStringPlaceholders(
         app_window_constants::kConflictingBoundsOptions, subst, NULL);
     return false;
   }
 
   return true;
 }
 
 // Copy over the bounds specification properties from the API to the
-// AppWindow::CreateParams.
+// native_app_window::CreateParams.
 void CopyBoundsSpec(const app_window::BoundsSpecification* input_spec,
-                    AppWindow::BoundsSpecification* create_spec) {
+                    native_app_window::BoundsSpecification* create_spec) {
   if (!input_spec)
     return;
 
   if (input_spec->left.get())
     create_spec->bounds.set_x(*input_spec->left);
   if (input_spec->top.get())
     create_spec->bounds.set_y(*input_spec->top);
   if (input_spec->width.get())
     create_spec->bounds.set_width(*input_spec->width);
   if (input_spec->height.get())
@@ skipping 31 matching lines @@
     } else {
       // Show error when url passed isn't local.
       error_ = app_window_constants::kInvalidUrlParameter;
       return false;
     }
   }
 
   // TODO(jeremya): figure out a way to pass the opening WebContents through to
   // AppWindow::Create so we can set the opener at create time rather than
   // with a hack in AppWindowCustomBindings::GetView().
-  AppWindow::CreateParams create_params;
+  native_app_window::AppWindowCreateParams create_params;
   app_window::CreateWindowOptions* options = params->options.get();
   if (options) {
     if (options->id.get()) {
       // TODO(mek): use URL if no id specified?
       // Limit length of id to 256 characters.
       if (options->id->length() > 256) {
         error_ = app_window_constants::kInvalidWindowId;
         return false;
       }
 
@@ skipping 38 matching lines @@
         }
       }
     }
 
     if (!GetBoundsSpec(*options, &create_params, &error_))
       return false;
 
     if (!AppWindowClient::Get()->IsCurrentChannelOlderThanDev() ||
         extension()->location() == extensions::Manifest::COMPONENT) {
       if (options->type == app_window::WINDOW_TYPE_PANEL) {
-        create_params.window_type = AppWindow::WINDOW_TYPE_PANEL;
+        create_params.window_type = native_app_window::WINDOW_TYPE_PANEL;
       }
     }
 
     if (!GetFrameOptions(*options, &create_params))
       return false;
 
     if (extension()->GetType() == extensions::Manifest::TYPE_EXTENSION) {
       // Whitelisted IME extensions are allowed to use this API to create IME
       // specific windows to show accented characters or suggestions.
       if (!extension()->permissions_data()->HasAPIPermission(
               APIPermission::kImeWindowEnabled)) {
         error_ = app_window_constants::kImeWindowMissingPermission;
         return false;
       }
 
 #if !defined(OS_CHROMEOS)
       // IME window is only supported on ChromeOS.
       error_ = app_window_constants::kImeWindowUnsupportedPlatform;
       return false;
 #else
       // IME extensions must create window with "ime: true" and "frame: none".
       if (!options->ime.get() || !*options->ime.get() ||
-          create_params.frame != AppWindow::FRAME_NONE) {
+          create_params.frame != native_app_window::FRAME_NONE) {
         error_ = app_window_constants::kImeOptionMustBeTrueAndNeedsFrameNone;
         return false;
       }
       create_params.is_ime_window = true;
 #endif  // OS_CHROMEOS
     } else {
       if (options->ime.get()) {
         error_ = app_window_constants::kImeOptionIsNotSupported;
         return false;
       }
@@ skipping 20 matching lines @@
               std::set<std::string>(whitelist,
                                     whitelist + arraysize(whitelist)))) {
         error_ = app_window_constants::kAlphaEnabledWrongChannel;
         return false;
       }
       if (!extension()->permissions_data()->HasAPIPermission(
               APIPermission::kAlphaEnabled)) {
         error_ = app_window_constants::kAlphaEnabledMissingPermission;
         return false;
       }
-      if (create_params.frame != AppWindow::FRAME_NONE) {
+      if (create_params.frame != native_app_window::FRAME_NONE) {
         error_ = app_window_constants::kAlphaEnabledNeedsFrameNone;
         return false;
       }
 #if defined(USE_AURA)
       create_params.alpha_enabled = *options->alpha_enabled;
 #else
       // Transparency is only supported on Aura.
       // Fallback to creating an opaque window (by ignoring alphaEnabled).
 #endif
     }
@@ skipping 78 matching lines @@
   }
 
   SendResponse(true);
   app_window->WindowEventsReady();
 
   return true;
 }
 
 bool AppWindowCreateFunction::GetBoundsSpec(
     const app_window::CreateWindowOptions& options,
-    AppWindow::CreateParams* params,
+    native_app_window::AppWindowCreateParams* params,
     std::string* error) {
   DCHECK(params);
   DCHECK(error);
 
   if (options.inner_bounds.get() || options.outer_bounds.get()) {
     // Parse the inner and outer bounds specifications. If developers use the
     // new API, the deprecated fields will be ignored - do not attempt to merge
     // them.
 
     const app_window::BoundsSpecification* inner_bounds =
@@ skipping 40 matching lines @@
                                "maxHeight",
                                error)) {
         return false;
       }
     }
 
     CopyBoundsSpec(inner_bounds, &(params->content_spec));
     CopyBoundsSpec(outer_bounds, &(params->window_spec));
   } else {
     // Parse deprecated fields.
-    // Due to a bug in NativeAppWindow::GetFrameInsets() on Windows and ChromeOS
+    // Due to a bug in Nativenative_app_window::GetFrameInsets() on Windows and
+    // ChromeOS
     // the bounds set the position of the window and the size of the content.
     // This will be preserved as apps may be relying on this behavior.
 
     if (options.default_width.get())
       params->content_spec.bounds.set_width(*options.default_width.get());
     if (options.default_height.get())
       params->content_spec.bounds.set_height(*options.default_height.get());
     if (options.default_left.get())
       params->window_spec.bounds.set_x(*options.default_left.get());
     if (options.default_top.get())
@@ skipping 28 matching lines @@
     gfx::Size& maximum_size = params->content_spec.maximum_size;
     if (options.max_width.get())
       maximum_size.set_width(*options.max_width);
     if (options.max_height.get())
       maximum_size.set_height(*options.max_height);
   }
 
   return true;
 }
 
-AppWindow::Frame AppWindowCreateFunction::GetFrameFromString(
+native_app_window::Frame AppWindowCreateFunction::GetFrameFromString(
     const std::string& frame_string) {
   if (frame_string == kHtmlFrameOption &&
       (extension()->permissions_data()->HasAPIPermission(
            APIPermission::kExperimental) ||
        CommandLine::ForCurrentProcess()->HasSwitch(
            switches::kEnableExperimentalExtensionApis))) {
      inject_html_titlebar_ = true;
-     return AppWindow::FRAME_NONE;
+     return native_app_window::FRAME_NONE;
    }
 
    if (frame_string == kNoneFrameOption)
-    return AppWindow::FRAME_NONE;
+     return native_app_window::FRAME_NONE;
 
-  return AppWindow::FRAME_CHROME;
+   return native_app_window::FRAME_CHROME;
 }
 
 bool AppWindowCreateFunction::GetFrameOptions(
     const app_window::CreateWindowOptions& options,
-    AppWindow::CreateParams* create_params) {
+    native_app_window::AppWindowCreateParams* create_params) {
   if (!options.frame)
     return true;
 
   DCHECK(options.frame->as_string || options.frame->as_frame_options);
   if (options.frame->as_string) {
     create_params->frame = GetFrameFromString(*options.frame->as_string);
     return true;
   }
 
   if (options.frame->as_frame_options->type)
     create_params->frame =
         GetFrameFromString(*options.frame->as_frame_options->type);
 
   if (options.frame->as_frame_options->color.get()) {
-    if (create_params->frame != AppWindow::FRAME_CHROME) {
+    if (create_params->frame != native_app_window::FRAME_CHROME) {
       error_ = app_window_constants::kColorWithFrameNone;
       return false;
     }
 
     if (!image_util::ParseCSSColorString(
             *options.frame->as_frame_options->color,
             &create_params->active_frame_color)) {
       error_ = app_window_constants::kInvalidColorSpecification;
       return false;
     }
@@ skipping 15 matching lines @@
 
   if (options.frame->as_frame_options->inactive_color.get()) {
     error_ = app_window_constants::kInactiveColorWithoutColor;
     return false;
   }
 
   return true;
 }
 
 }  // namespace extensions