Refactor guest view availability to be API not permission based.

chrome/browser/guest_view/guest_view_base.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 "chrome/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/guest_view/app_view/app_view_guest.h"
 #include "chrome/browser/guest_view/extension_options/extension_options_guest.h"
 #include "chrome/browser/guest_view/guest_view_constants.h"
 #include "chrome/browser/guest_view/guest_view_manager.h"
 #include "chrome/browser/guest_view/web_view/web_view_guest.h"
 #include "chrome/common/content_settings.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/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/process_map.h"
+#include "extensions/common/features/feature.h"
+#include "extensions/common/features/feature_provider.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 using content::WebContents;
 
 namespace {
 
 typedef std::map<std::string, GuestViewBase::GuestCreationCallback>
     GuestViewCreationMap;
 static base::LazyInstance<GuestViewCreationMap> guest_view_registry =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 59 matching lines @@
     : embedder_web_contents_(NULL),
       embedder_render_process_id_(0),
       browser_context_(browser_context),
       guest_instance_id_(guest_instance_id),
       view_instance_id_(guestview::kInstanceIDNone),
       initialized_(false),
       auto_size_enabled_(false),
       weak_ptr_factory_(this) {
 }
 
-void GuestViewBase::Init(
-    const std::string& embedder_extension_id,
-    int embedder_render_process_id,
-    const base::DictionaryValue& create_params,
-    const WebContentsCreatedCallback& callback) {
+void GuestViewBase::Init(const std::string& embedder_extension_id,
+                         content::WebContents* embedder_web_contents,
+                         const base::DictionaryValue& create_params,
+                         const WebContentsCreatedCallback& callback) {
   if (initialized_)
     return;
   initialized_ = true;
 
-  if (!CanEmbedderUseGuestView(embedder_extension_id)) {
+  extensions::Feature* feature =
+      extensions::FeatureProvider::GetAPIFeatures()->GetFeature(
+          GetApiNamespace());
+  CHECK(feature);

[Fady Samuel, 2014/08/07 23:01:18]

Do we really want to kill the browser in this case?

[not at google - send to devlin, 2014/08/07 23:02:55]

yes, because it can't possibly happen unless somebody mistypes the API name, and
that would be bad, and we don't want to hide that.

+
+  extensions::ProcessMap* process_map =
+      extensions::ProcessMap::Get(browser_context());
+  CHECK(process_map);
+
+  const extensions::Extension* embedder_extension =
+      extensions::ExtensionRegistry::Get(browser_context_)
+          ->enabled_extensions()
+          .GetByID(embedder_extension_id);
+  int embedder_process_id =
+      embedder_web_contents->GetRenderProcessHost()->GetID();
+
+  extensions::Feature::Availability availability =
+      feature->IsAvailableToContext(
+          embedder_extension,
+          process_map->GuessContextType(embedder_extension,
+                                        embedder_process_id),
+          embedder_web_contents->GetLastCommittedURL());
+  if (!availability.is_available()) {
     callback.Run(NULL);
     return;
   }
 
   CreateWebContents(embedder_extension_id,
-                    embedder_render_process_id,
+                    embedder_process_id,
                     create_params,
                     base::Bind(&GuestViewBase::CompleteInit,
                                AsWeakPtr(),
                                embedder_extension_id,
-                               embedder_render_process_id,
+                               embedder_process_id,
                                callback));
 }
 
 void GuestViewBase::InitWithWebContents(
     const std::string& embedder_extension_id,
     int embedder_render_process_id,
     content::WebContents* guest_web_contents) {
   DCHECK(guest_web_contents);
   content::RenderProcessHost* embedder_render_process_host =
       content::RenderProcessHost::FromID(embedder_render_process_id);
@@ skipping 309 matching lines @@
                       guest_web_contents);
   callback.Run(guest_web_contents);
 }
 
 // static
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   WebViewGuest::Register();
 }