Moved guest_view_registry to GuestViewManager and made it an instance map

extensions/browser/guest_view/guest_view_manager.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 "extensions/browser/guest_view/guest_view_manager.h"
 
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
+#include "extensions/browser/guest_view/app_view/app_view_guest.h"
+#include "extensions/browser/guest_view/extension_options/extension_options_guest.h"
+#include "extensions/browser/guest_view/extension_view/extension_view_guest.h"
 #include "extensions/browser/guest_view/guest_view_base.h"
 #include "extensions/browser/guest_view/guest_view_manager_factory.h"
+#include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
+#include "extensions/browser/guest_view/surface_worker/surface_worker_guest.h"
+#include "extensions/browser/guest_view/web_view/web_view_guest.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/guest_view/guest_view_constants.h"
 #include "net/base/escape.h"
 #include "url/gurl.h"
 
 using content::BrowserContext;
 using content::SiteInstance;
@@ skipping 88 matching lines @@
 }
 
 int GuestViewManager::GetNextInstanceID() {
   return ++current_instance_id_;
 }
 
 void GuestViewManager::CreateGuest(const std::string& view_type,
                                    content::WebContents* owner_web_contents,
                                    const base::DictionaryValue& create_params,
                                    const WebContentsCreatedCallback& callback) {
-  auto guest = GuestViewBase::Create(owner_web_contents, view_type);
+  GuestViewBase* guest = CreateGuestInternal(owner_web_contents, view_type);
   if (!guest) {
     callback.Run(nullptr);
     return;
   }
   guest->Init(create_params, callback);
 }
 
 content::WebContents* GuestViewManager::CreateGuestWithWebContentsParams(
     const std::string& view_type,
     content::WebContents* owner_web_contents,
     const content::WebContents::CreateParams& create_params) {
-  auto guest = GuestViewBase::Create(owner_web_contents, view_type);
+  auto guest = CreateGuestInternal(owner_web_contents, view_type);
   if (!guest)
     return nullptr;
   content::WebContents::CreateParams guest_create_params(create_params);
   guest_create_params.guest_delegate = guest;
   auto guest_web_contents = WebContents::Create(guest_create_params);
   guest->InitWithWebContents(base::DictionaryValue(), guest_web_contents);
   return guest_web_contents;
 }
 
 content::WebContents* GuestViewManager::GetGuestByInstanceID(
@@ skipping 74 matching lines @@
       if (instance_id != last_instance_id_removed_ + 1)
         break;
       ++last_instance_id_removed_;
       removed_instance_ids_.erase(iter++);
     }
   } else {
     removed_instance_ids_.insert(guest_instance_id);
   }
 }
 
+GuestViewBase* GuestViewManager::CreateGuestInternal(
+    content::WebContents* owner_web_contents,
+    const std::string& view_type) {
+  if (guest_view_registry_.empty())
+    RegisterGuestViewTypes();
+
+  auto it = guest_view_registry_.find(view_type);
+  if (it == guest_view_registry_.end()) {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  return it->second.Run(owner_web_contents);
+}
+
+// static
+void GuestViewManager::RegisterGuestViewTypes() {
+  RegisterGuestViewType<AppViewGuest>();
+  RegisterGuestViewType<ExtensionOptionsGuest>();
+  RegisterGuestViewType<ExtensionViewGuest>();
+  RegisterGuestViewType<MimeHandlerViewGuest>();
+  RegisterGuestViewType<SurfaceWorkerGuest>();
+  RegisterGuestViewType<WebViewGuest>();
+}
+
 bool GuestViewManager::IsGuestAvailableToContext(
     GuestViewBase* guest,
     std::string* owner_extension_id) {
   const Feature* feature =
       FeatureProvider::GetAPIFeature(guest->GetAPINamespace());
   CHECK(feature);
 
   ProcessMap* process_map = ProcessMap::Get(context_);
   CHECK(process_map);
 
@@ skipping 90 matching lines @@
   return element_instance_id < other.element_instance_id;
 }
 
 bool GuestViewManager::ElementInstanceKey::operator==(
     const GuestViewManager::ElementInstanceKey& other) const {
   return (embedder_process_id == other.embedder_process_id) &&
     (element_instance_id == other.element_instance_id);
 }
 
 }  // namespace extensions