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 "grit/generated_resources.h"
 #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"
 
 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";
@@ skipping 14 matching lines @@
 // 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 182 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);
 
       // Let the controller for the target TabContents know that it is hosting a
       // web intents service.
@@ skipping 122 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));
+      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 290 matching lines @@
 void WebIntentPickerController::AsyncOperationFinished() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (--pending_async_count_ == 0) {
     if (picker_)
       picker_->OnPendingAsyncCompleted();
   }
 }
 
 void WebIntentPickerController::InvokeService(
     const WebIntentPickerModel::InstalledService& service) {
-  if (service.disposition == WebIntentPickerModel::DISPOSITION_INLINE) {
+  if (service.disposition ==
+      webkit_glue::WebIntentServiceData::DISPOSITION_INLINE) {
     SetDialogState(kPickerMain);
   }
   OnServiceChosen(service.url, service.disposition);
 }
 
 void WebIntentPickerController::SetDialogState(WebIntentPickerState state) {
   // Ignore events that don't change state.
   if (state == dialog_state_)
     return;
 
@@ skipping 56 matching lines @@
   picker_->SetActionString(GetIntentActionString(
       UTF16ToUTF8(picker_model_->action())));
   picker_shown_ = true;
 }
 
 void WebIntentPickerController::ClosePicker() {
   SetDialogState(kPickerHidden);
   if (picker_)
     picker_->Close();
 }