intents: Remove the disposition enum in web intents model.

chrome/browser/ui/intents/web_intent_picker_controller.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 "chrome/browser/ui/intents/web_intent_picker_controller.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 30 matching lines @@
 #include "ipc/ipc_message.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image.h"
 #include "webkit/glue/web_intent_service_data.h"
 

[groby-ooo-7-16, 2012/08/10 18:36:31]

#include "webkit/glue/web_intent_service_data.h"

[Greg Billock, 2012/08/15 18:16:37]

Was here one line up, but moving to .h file.

 using extensions::WebstoreInstaller;
 
 namespace {
 
 const char kShareActionURL[] = "http://webintents.org/share";
 const char kEditActionURL[] = "http://webintents.org/edit";
 const char kViewActionURL[] = "http://webintents.org/view";
 const char kPickActionURL[] = "http://webintents.org/pick";
 const char kSubscribeActionURL[] = "http://webintents.org/subscribe";
 const char kSaveActionURL[] = "http://webintents.org/save";
 
 // Gets the favicon service for the profile in |tab_contents|.
 FaviconService* GetFaviconService(TabContents* tab_contents) {
   return tab_contents->profile()->GetFaviconService(Profile::EXPLICIT_ACCESS);
 }
 
 // Gets the web intents registry for the profile in |tab_contents|.
 WebIntentsRegistry* GetWebIntentsRegistry(TabContents* tab_contents) {
   return WebIntentsRegistryFactory::GetForProfile(tab_contents->profile());
 }
 
 // Gets the Chrome web store intents registry for the profile in |tab_contents|.
 CWSIntentsRegistry* GetCWSIntentsRegistry(TabContents* tab_contents) {
   return CWSIntentsRegistryFactory::GetForProfile(tab_contents->profile());
 }
 
-WebIntentPickerModel::Disposition ConvertDisposition(
-    webkit_glue::WebIntentServiceData::Disposition disposition) {
-  switch (disposition) {
-    case webkit_glue::WebIntentServiceData::DISPOSITION_INLINE:
-      return WebIntentPickerModel::DISPOSITION_INLINE;
-    case webkit_glue::WebIntentServiceData::DISPOSITION_WINDOW:
-      return WebIntentPickerModel::DISPOSITION_WINDOW;
-    default:
-      NOTREACHED();
-      return WebIntentPickerModel::DISPOSITION_WINDOW;
-  }
-}
-
 // Returns the action-specific string for |action|.
 string16 GetIntentActionString(const std::string& action) {
   if (!action.compare(kShareActionURL))
     return l10n_util::GetStringUTF16(IDS_WEB_INTENTS_ACTION_SHARE);
   else if (!action.compare(kEditActionURL))
     return l10n_util::GetStringUTF16(IDS_WEB_INTENTS_ACTION_EDIT);
   else if (!action.compare(kViewActionURL))
     return l10n_util::GetStringUTF16(IDS_WEB_INTENTS_ACTION_VIEW);
   else if (!action.compare(kPickActionURL))
     return l10n_util::GetStringUTF16(IDS_WEB_INTENTS_ACTION_PICK);
@@ skipping 172 matching lines @@
 
 void WebIntentPickerController::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == content::NOTIFICATION_LOAD_START ||
          type == chrome::NOTIFICATION_TAB_CLOSING);
   ClosePicker();
 }
 
-void WebIntentPickerController::OnServiceChosen(const GURL& url,
-                                                Disposition disposition) {
+void WebIntentPickerController::OnServiceChosen(
+    const GURL& url,
+    webkit_glue::WebIntentServiceData::Disposition disposition) {
   ExtensionService* service = tab_contents_->profile()->GetExtensionService();
   DCHECK(service);
   const extensions::Extension* extension = service->GetInstalledApp(url);
   if (extension && extension->is_platform_app()) {
     extensions::LaunchPlatformAppWithWebIntent(tab_contents_->profile(),
         extension, intents_dispatcher_->GetIntent());
     // TODO(benwells): hook up return pathway to allow platform app to post
     // success or failure.
     intents_dispatcher_->SendReplyMessage(
         webkit_glue::WEB_INTENT_REPLY_SUCCESS, string16());
     ClosePicker();
     return;
   }
 
   switch (disposition) {
-    case WebIntentPickerModel::DISPOSITION_INLINE:
+    case webkit_glue::WebIntentServiceData::DISPOSITION_INLINE:
       // Set the model to inline disposition. It will notify the picker which
       // will respond (via OnInlineDispositionWebContentsCreated) with the
       // WebContents to dispatch the intent to.
       picker_model_->SetInlineDisposition(url);
       break;
 
-    case WebIntentPickerModel::DISPOSITION_WINDOW: {
+    case webkit_glue::WebIntentServiceData::DISPOSITION_WINDOW: {
       Browser* browser = browser::FindBrowserWithWebContents(
           tab_contents_->web_contents());
       TabContents* contents = chrome::TabContentsFactory(
           tab_contents_->profile(),
           tab_util::GetSiteInstanceForNewTab(
               tab_contents_->profile(), url),
           MSG_ROUTING_NONE, NULL, NULL);
 
       // Let the controller for the target TabContents know that it is hosting a
       // web intents service.
@@ skipping 123 matching lines @@
   // Extension must be registered with registry by now.
   DCHECK(services.size() > 0);
 
   // TODO(binji): We're going to need to disambiguate if there are multiple
   // services. For now, just choose the first.
   const webkit_glue::WebIntentServiceData& service_data = services[0];
 
   picker_model_->AddInstalledService(
       service_data.title, service_data.service_url,
       ConvertDisposition(service_data.disposition));
-  OnServiceChosen(
-      service_data.service_url,
-      ConvertDisposition(service_data.disposition));
+  OnServiceChosen(service_data.service_url, service_data.disposition);
   AsyncOperationFinished();
 }
 
 void WebIntentPickerController::OnExtensionInstallFailure(
     const std::string& id,
     const std::string& error) {
   picker_->OnExtensionInstallFailure(id);
   AsyncOperationFinished();
 }
 
@@ skipping 25 matching lines @@
   intents_dispatcher_ = NULL;
 }
 
 void WebIntentPickerController::AddServiceToModel(
     const webkit_glue::WebIntentServiceData& service) {
   FaviconService* favicon_service = GetFaviconService(tab_contents_);
 
   picker_model_->AddInstalledService(
       service.title,
       service.service_url,
-      ConvertDisposition(service.disposition));
+      service.disposition);
 
   pending_async_count_++;
   FaviconService::Handle handle = favicon_service->GetFaviconForURL(
       service.service_url,
       history::FAVICON,
       &favicon_consumer_,
       base::Bind(
           &WebIntentPickerController::OnFaviconDataAvailable,
           weak_ptr_factory_.GetWeakPtr()));
   favicon_consumer_.SetClientData(
@@ skipping 15 matching lines @@
   DCHECK(intents_dispatcher_->GetIntent().service.is_valid());
   for (size_t i = 0; i < services.size(); ++i) {
     if (services[i].service_url != intents_dispatcher_->GetIntent().service)
       continue;
 
     AddServiceToModel(services[i]);
 
     if (services[i].disposition ==
         webkit_glue::WebIntentServiceData::DISPOSITION_INLINE)
       CreatePicker();
-    OnServiceChosen(services[i].service_url,
-                    ConvertDisposition(services[i].disposition));
+    OnServiceChosen(services[i].service_url, services[i].disposition);
     AsyncOperationFinished();
     return;
   }
 
   // No acceptable extension. The intent cannot be dispatched.
   intents_dispatcher_->SendReplyMessage(
       webkit_glue::WEB_INTENT_REPLY_FAILURE,  ASCIIToUTF16(
           "Explicit extension URL is not available."));
 
   AsyncOperationFinished();
@@ skipping 16 matching lines @@
 
   if (picker_model_->default_service_url().is_valid()) {
     // If there's a default service, dispatch to it immediately
     // without showing the picker.
     const WebIntentPickerModel::InstalledService* default_service =
         picker_model_->GetInstalledServiceWithURL(
             GURL(picker_model_->default_service_url()));
 
     if (default_service != NULL) {
       if (default_service->disposition ==
-          WebIntentPickerModel::DISPOSITION_INLINE)
+          webkit_glue::WebIntentServiceData::DISPOSITION_INLINE)
         CreatePicker();
 
       OnServiceChosen(default_service->url, default_service->disposition);
       return;
     }
   }
 
   CreatePicker();
   picker_->SetActionString(GetIntentActionString(
       UTF16ToUTF8(picker_model_->action())));
@@ skipping 182 matching lines @@
   // If picker is non-NULL, it was set by a test.
   if (picker_ == NULL)
     picker_ = WebIntentPicker::Create(tab_contents_, this, picker_model_.get());
   picker_shown_ = true;
 }
 
 void WebIntentPickerController::ClosePicker() {
   if (picker_)
     picker_->Close();
 }