Reland r167487: Get full WebPluginInfo for the PDF plug-in before enabling it for print preview.

ui/base/win/window_impl.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 "ui/base/win/window_impl.h"
 
 #include <list>
 
 #include "base/debug/alias.h"
 #include "base/memory/singleton.h"
@@ skipping 26 matching lines @@
         icon(icon) {}
 
   // Compares two ClassInfos. Returns true if all members match.
   bool Equals(const ClassInfo& other) const {
     return (other.style == style && other.icon == icon);
   }
 };
 
 class ClassRegistrar {
  public:
-  static ClassRegistrar* GetInstance() {
-    return Singleton<ClassRegistrar>::get();
-  }
+  ~ClassRegistrar();
 
-  ~ClassRegistrar() {
-    for (RegisteredClasses::iterator i = registered_classes_.begin();
-         i != registered_classes_.end(); ++i) {
-      if (!UnregisterClass(MAKEINTATOM(i->atom), i->instance)) {
-        LOG(ERROR) << "Failed to unregister class " << i->name.c_str()
-                   << ". Error = " << GetLastError();
-      }
-    }
-  }
+  static ClassRegistrar* GetInstance();
 
-  // Puts the name for the class matching |class_info| in |class_name|, creating
-  // a new name if the class is not yet known.
-  // Returns true if this class was already known, false otherwise.
-  bool RetrieveClassName(const ClassInfo& class_info, std::wstring* name) {
-    for (RegisteredClasses::const_iterator i = registered_classes_.begin();
-         i != registered_classes_.end(); ++i) {
-      if (class_info.Equals(i->info)) {
-        name->assign(i->name);
-        return true;
-      }
-    }
-
-    name->assign(string16(WindowImpl::kBaseClassName) +
-        base::IntToString16(registered_count_++));
-    return false;
-  }
-
-  void RegisterClass(const ClassInfo& class_info,
-                     const std::wstring& name,
-                     ATOM atom,
-                     HMODULE instance) {
-    registered_classes_.push_back(
-        RegisteredClass(class_info, name, atom, instance));
-  }
+  // Returns the atom identifying the class matching |class_info|,
+  // creating and registering a new class if the class is not yet known.
+  ATOM RetrieveClassAtom(const ClassInfo& class_info);
 
  private:
   // Represents a registered window class.
   struct RegisteredClass {
-    RegisteredClass(const ClassInfo& info,
-                    const std::wstring& name,
-                    ATOM atom,
-                    HMODULE instance)
-        : info(info),
-          name(name),
-          atom(atom),
-          instance(instance) {
-    }
+    RegisteredClass(const ClassInfo& info, ATOM atom);
 
     // Info used to create the class.
     ClassInfo info;
 
-    // The name given to the window class.
-    std::wstring name;
-
-    // The ATOM returned from registering the window class.
+    // The atom identifying the window class.
     ATOM atom;
-
-    // The handle of the module containing the window procedure.
-    HMODULE instance;
   };
 
-  ClassRegistrar() : registered_count_(0) { }
+  ClassRegistrar();
   friend struct DefaultSingletonTraits<ClassRegistrar>;
 
   typedef std::list<RegisteredClass> RegisteredClasses;
   RegisteredClasses registered_classes_;
 
   // Counter of how many classes have been registered so far.
   int registered_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ClassRegistrar);
 };
 
+ClassRegistrar::~ClassRegistrar() {}
+
+// static
+ClassRegistrar* ClassRegistrar::GetInstance() {
+  return Singleton<ClassRegistrar,
+                   LeakySingletonTraits<ClassRegistrar> >::get();
+}
+
+ATOM ClassRegistrar::RetrieveClassAtom(const ClassInfo& class_info) {
+  for (RegisteredClasses::const_iterator i = registered_classes_.begin();
+       i != registered_classes_.end(); ++i) {
+    if (class_info.Equals(i->info))
+      return i->atom;
+  }
+
+  // No class found, need to register one.
+  string16 name = string16(WindowImpl::kBaseClassName) +
+      base::IntToString16(registered_count_++);
+
+  HBRUSH background = NULL;
+  WNDCLASSEX window_class;
+  base::win::InitializeWindowClass(
+      name.c_str(),
+      &base::win::WrappedWindowProc<WindowImpl::WndProc>,
+      class_info.style,
+      0,
+      0,
+      NULL,
+      reinterpret_cast<HBRUSH>(background + 1),
+      NULL,
+      class_info.icon,
+      class_info.icon,
+      &window_class);
+  HMODULE instance = window_class.hInstance;
+  ATOM atom = RegisterClassEx(&window_class);
+  CHECK(atom) << GetLastError();
+
+  registered_classes_.push_back(RegisteredClass(class_info, atom));
+
+  return atom;
+}
+
+ClassRegistrar::RegisteredClass::RegisteredClass(const ClassInfo& info,
+                                                 ATOM atom)
+    : info(info),
+      atom(atom) {}
+
+ClassRegistrar::ClassRegistrar() : registered_count_(0) { }
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // WindowImpl, public
 
 WindowImpl::WindowImpl()
     : window_style_(0),
       window_ex_style_(kWindowDefaultExStyle),
       class_style_(CS_DBLCLKS),
       hwnd_(NULL),
       got_create_(false),
       got_valid_hwnd_(false),
@@ skipping 24 matching lines @@
   int x, y, width, height;
   if (bounds.IsEmpty()) {
     x = y = width = height = CW_USEDEFAULT;
   } else {
     x = bounds.x();
     y = bounds.y();
     width = bounds.width();
     height = bounds.height();
   }
 
-  std::wstring name(GetWindowClassName());
+  ATOM atom = GetWindowClassAtom();
   bool destroyed = false;
   destroyed_ = &destroyed;
-  HWND hwnd = CreateWindowEx(window_ex_style_, name.c_str(), NULL,
+  HWND hwnd = CreateWindowEx(window_ex_style_,
+                             reinterpret_cast<wchar_t*>(atom), NULL,
                              window_style_, x, y, width, height,
                              parent, NULL, NULL, this);
   if (!hwnd_ && GetLastError() == 0) {
     base::debug::Alias(&destroyed);
     base::debug::Alias(&hwnd);
     bool got_create = got_create_;
     base::debug::Alias(&got_create);
     bool got_valid_hwnd = got_valid_hwnd_;
     base::debug::Alias(&got_valid_hwnd);
     WNDCLASSEX class_info;
     memset(&class_info, 0, sizeof(WNDCLASSEX));
     class_info.cbSize = sizeof(WNDCLASSEX);
-    BOOL got_class = GetClassInfoEx(
-        GetModuleHandle(NULL), name.c_str(), &class_info);
+    BOOL got_class = GetClassInfoEx(GetModuleHandle(NULL),
+                                    reinterpret_cast<wchar_t*>(atom),
+                                    &class_info);
     base::debug::Alias(&got_class);
     bool procs_match = got_class && class_info.lpfnWndProc ==
         base::win::WrappedWindowProc<&WindowImpl::WndProc>;
     base::debug::Alias(&procs_match);
     CHECK(false);
   }
   if (!destroyed)
     destroyed_ = NULL;
 
   CheckWindowCreated(hwnd_);
@@ skipping 40 matching lines @@
   }
 
   WindowImpl* window = reinterpret_cast<WindowImpl*>(
       ui::GetWindowUserData(hwnd));
   if (!window)
     return 0;
 
   return window->OnWndProc(message, w_param, l_param);
 }
 
-std::wstring WindowImpl::GetWindowClassName() {
+ATOM WindowImpl::GetWindowClassAtom() {
   HICON icon = GetDefaultWindowIcon();
   ClassInfo class_info(initial_class_style(), icon);
-  std::wstring name;
-  if (ClassRegistrar::GetInstance()->RetrieveClassName(class_info, &name))
-    return name;
-
-  // No class found, need to register one.
-  HBRUSH background = NULL;
-  WNDCLASSEX window_class;
-  base::win::InitializeWindowClass(
-      name.c_str(),
-      &base::win::WrappedWindowProc<WindowImpl::WndProc>,
-      class_info.style,
-      0,
-      0,
-      NULL,
-      reinterpret_cast<HBRUSH>(background + 1),
-      NULL,
-      icon,
-      icon,
-      &window_class);
-  HMODULE instance = window_class.hInstance;
-  ATOM atom = RegisterClassEx(&window_class);
-  CHECK(atom) << GetLastError();
-
-  ClassRegistrar::GetInstance()->RegisterClass(
-      class_info, name, atom, instance);
-
-  return name;
+  return ClassRegistrar::GetInstance()->RetrieveClassAtom(class_info);
 }
 
 }  // namespace ui