Add support for Twitter tips

browser/brave_rewards/tip_dialog.cc

@@ -7,12 +7,13 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
-#include "base/values.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
 #include "brave/common/webui_url_constants.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
@@ -37,7 +38,7 @@ constexpr int kDialogMaxHeight = 700;
 class TipDialogDelegate : public ui::WebDialogDelegate {
  public:
   explicit TipDialogDelegate(WebContents* initiator,
-                                          std::string publisher_key);
+      std::unique_ptr<base::DictionaryValue> params);
   ~TipDialogDelegate() override;
 
   ui::ModalType GetDialogModalType() const override;
@@ -53,15 +54,14 @@ class TipDialogDelegate : public ui::WebDialogDelegate {
 
  private:
   WebContents* initiator_;
-  const std::string publisher_key_;
+  std::unique_ptr<base::DictionaryValue> params_;
 
   DISALLOW_COPY_AND_ASSIGN(TipDialogDelegate);
 };
 
 TipDialogDelegate::TipDialogDelegate(WebContents* initiator,
-                                                    std::string publisher_key)
-    : initiator_(initiator),
-      publisher_key_(publisher_key) {
+    std::unique_ptr<base::DictionaryValue> params)
+  : initiator_(initiator), params_(std::move(params)) {
 }
 
 TipDialogDelegate::~TipDialogDelegate() {
@@ -111,11 +111,9 @@ void TipDialogDelegate::GetDialogSize(gfx::Size* size) const {
 }
 
 std::string TipDialogDelegate::GetDialogArgs() const {
-  std::string data;
-  base::DictionaryValue dialog_args;
-  dialog_args.SetString("publisherKey", publisher_key_);
-  base::JSONWriter::Write(dialog_args, &data);
-  return data;
+  std::string json;
+  base::JSONWriter::Write(*params_, &json);
+  return json;
 }
 
 void TipDialogDelegate::OnDialogClosed(
@@ -136,7 +134,7 @@ bool TipDialogDelegate::ShouldShowDialogTitle() const {
 namespace brave_rewards {
 
 void OpenTipDialog(WebContents* initiator,
-                   const std::string& publisher_key) {
+                   std::unique_ptr<base::DictionaryValue> params) {
   content::WebContents* outermost_web_contents =
     guest_view::GuestViewBase::GetTopLevelWebContents(initiator);
   gfx::Size host_size = outermost_web_contents->GetContainerBounds().size();
@@ -147,7 +145,7 @@ void OpenTipDialog(WebContents* initiator,
   // resize)
   ShowConstrainedWebDialogWithAutoResize(
       initiator->GetBrowserContext(),
-      std::make_unique<TipDialogDelegate>(initiator, publisher_key),
+      std::make_unique<TipDialogDelegate>(initiator, std::move(params)),
       initiator, min_size, max_size);
 }
 

browser/brave_rewards/tip_dialog.h

@@ -6,16 +6,21 @@
 #ifndef BRAVE_BROWSER_BRAVE_REWARDS_TIP_DIALOG_H_
 #define BRAVE_BROWSER_BRAVE_REWARDS_TIP_DIALOG_H_
 
+#include <memory>
 #include <string>
 
+namespace base {
+class DictionaryValue;
+}
+
 namespace content {
 class WebContents;
 }
 
 namespace brave_rewards {
 
 void OpenTipDialog(content::WebContents* initiator,
-                   const std::string& publisher_key);
+                   std::unique_ptr<base::DictionaryValue> params);
 
 }
 

browser/extensions/api/brave_rewards_api.cc

@@ -5,6 +5,7 @@
 
 #include "brave/browser/extensions/api/brave_rewards_api.h"
 
+#include <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ -13,19 +14,19 @@
 #include "base/strings/string_number_conversions.h"
 #include "brave/browser/brave_rewards/tip_dialog.h"
 #include "brave/common/extensions/api/brave_rewards.h"
-#include "brave/components/brave_rewards/browser/rewards_service.h"
-#include "brave/components/brave_rewards/browser/rewards_service_factory.h"
 #include "brave/components/brave_ads/browser/ads_service.h"
 #include "brave/components/brave_ads/browser/ads_service_factory.h"
-#include "content/public/browser/web_contents.h"
+#include "brave/components/brave_rewards/browser/rewards_service.h"
+#include "brave/components/brave_rewards/browser/rewards_service_factory.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/web_contents.h"
 
-using brave_rewards::RewardsService;
-using brave_rewards::RewardsServiceFactory;
 using brave_ads::AdsService;
 using brave_ads::AdsServiceFactory;
+using brave_rewards::RewardsService;
+using brave_rewards::RewardsServiceFactory;
 
 namespace extensions {
 namespace api {
@@ -62,19 +63,104 @@ ExtensionFunction::ResponseAction BraveRewardsTipSiteFunction::Run() {
   if (!ExtensionTabUtil::GetTabById(
         params->tab_id,
         profile,
-        include_incognito_information(),
+        false,
         nullptr,
         nullptr,
         &contents,
         nullptr)) {
     return RespondNow(Error(tabs_constants::kTabNotFoundError,
                             base::NumberToString(params->tab_id)));
   }
-  ::brave_rewards::OpenTipDialog(contents, params->publisher_key);
+
+  auto params_dict = std::make_unique<base::DictionaryValue>();
+  params_dict->SetString("publisherKey", params->publisher_key);
+  ::brave_rewards::OpenTipDialog(contents, std::move(params_dict));
 
   return RespondNow(NoArguments());
 }
 
+BraveRewardsTipTwitterUserFunction::BraveRewardsTipTwitterUserFunction()
+    : weak_factory_(this) {
+}
+
+BraveRewardsTipTwitterUserFunction::~BraveRewardsTipTwitterUserFunction() {
+}
+
+ExtensionFunction::ResponseAction
+BraveRewardsTipTwitterUserFunction::Run() {
+  std::unique_ptr<brave_rewards::TipTwitterUser::Params> params(
+      brave_rewards::TipTwitterUser::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  // Sanity check: don't allow tips in private / tor contexts,
+  // although the command should not have been enabled in the first place.
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  if (profile->IsOffTheRecord()) {
+    return RespondNow(
+        Error("Cannot tip Twitter user in a private context"));
+  }
+
+  auto* rewards_service = RewardsServiceFactory::GetForProfile(profile);
+  if (rewards_service) {
+    AddRef();
+    std::map<std::string, std::string> args;
+    args["user_id"] = params->tweet_meta_data.user_id;
+    args["name"] = params->tweet_meta_data.name;
+    args["screen_name"] = params->tweet_meta_data.screen_name;
+    rewards_service->SaveTwitterPublisherInfo(
+        args,
+        base::Bind(&BraveRewardsTipTwitterUserFunction::
+                   OnTwitterPublisherInfoSaved,
+                   weak_factory_.GetWeakPtr()));
+  }
+
+  return RespondNow(NoArguments());
+}
+
+void BraveRewardsTipTwitterUserFunction::OnTwitterPublisherInfoSaved(
+    std::unique_ptr<::brave_rewards::ContentSite> publisher_info) {
+  std::unique_ptr<brave_rewards::TipTwitterUser::Params> params(
+      brave_rewards::TipTwitterUser::Params::Create(*args_));
+
+  if (!publisher_info) {
+    // TODO(nejczdovc): what should we do in this case?
+    Release();
+    return;
+  }
+
+  // Get web contents for this tab
+  content::WebContents* contents = nullptr;
+  if (!ExtensionTabUtil::GetTabById(
+        params->tab_id,
+        Profile::FromBrowserContext(browser_context()),
+        false,
+        nullptr,
+        nullptr,
+        &contents,
+        nullptr)) {
+    return;
+  }
+
+  auto params_dict = std::make_unique<base::DictionaryValue>();
+  params_dict->SetString("publisherKey", publisher_info->id);
+
+  auto tweet_meta_data_dict = std::make_unique<base::DictionaryValue>();
+  tweet_meta_data_dict->SetString("name", publisher_info->name);
+  tweet_meta_data_dict->SetString("screenName",
+                                  params->tweet_meta_data.screen_name);
+  tweet_meta_data_dict->SetString("userId", params->tweet_meta_data.user_id);
+  tweet_meta_data_dict->SetString("tweetId", params->tweet_meta_data.tweet_id);
+  tweet_meta_data_dict->SetInteger("tweetTimestamp",
+                                   params->tweet_meta_data.tweet_timestamp);
+  tweet_meta_data_dict->SetString("tweetText",
+                                  params->tweet_meta_data.tweet_text);
+  params_dict->SetDictionary("tweetMetaData", std::move(tweet_meta_data_dict));
+
+  ::brave_rewards::OpenTipDialog(contents, std::move(params_dict));
+
+  Release();
+}
+
 BraveRewardsGetPublisherDataFunction::~BraveRewardsGetPublisherDataFunction() {
 }
 
@@ -492,5 +578,33 @@ BraveRewardsGetAllNotificationsFunction::Run() {
   return RespondNow(OneArgument(std::move(list)));
 }
 
+BraveRewardsGetInlineTipSettingFunction::
+~BraveRewardsGetInlineTipSettingFunction() {
+}
+
+ExtensionFunction::ResponseAction
+BraveRewardsGetInlineTipSettingFunction::Run() {
+  std::unique_ptr<brave_rewards::GetInlineTipSetting::Params> params(
+      brave_rewards::GetInlineTipSetting::Params::Create(*args_));
+
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  RewardsService* rewards_service =
+    RewardsServiceFactory::GetForProfile(profile);
+  if (!rewards_service) {
+    return RespondNow(OneArgument(std::make_unique<base::Value>(false)));
+  }
+
+  rewards_service->GetInlineTipSetting(
+      params->key,
+      base::BindOnce(
+          &BraveRewardsGetInlineTipSettingFunction::OnInlineTipSetting,
+          this));
+  return RespondLater();
+}
+
+void BraveRewardsGetInlineTipSettingFunction::OnInlineTipSetting(bool value) {
+  Respond(OneArgument(std::make_unique<base::Value>(value)));
+}
+
 }  // namespace api
 }  // namespace extensions

browser/extensions/api/brave_rewards_api.h

@@ -9,9 +9,10 @@
 #include <memory>
 #include <string>
 
-#include "extensions/browser/extension_function.h"
+#include "base/memory/weak_ptr.h"
 #include "brave/components/brave_rewards/browser/content_site.h"
 #include "brave/components/brave_rewards/browser/publisher_banner.h"
+#include "extensions/browser/extension_function.h"
 
 namespace extensions {
 namespace api {
@@ -36,6 +37,23 @@ class BraveRewardsTipSiteFunction : public UIThreadExtensionFunction {
   ResponseAction Run() override;
 };
 
+class BraveRewardsTipTwitterUserFunction
+    : public UIThreadExtensionFunction {
+ public:
+  BraveRewardsTipTwitterUserFunction();
+  DECLARE_EXTENSION_FUNCTION("braveRewards.tipTwitterUser", UNKNOWN)
+
+ protected:
+  ~BraveRewardsTipTwitterUserFunction() override;
+
+  ResponseAction Run() override;
+
+ private:
+  base::WeakPtrFactory<BraveRewardsTipTwitterUserFunction> weak_factory_;
+  void OnTwitterPublisherInfoSaved(
+      std::unique_ptr<brave_rewards::ContentSite> publisher_info);
+};
+
 class BraveRewardsGetPublisherDataFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("braveRewards.getPublisherData", UNKNOWN)
@@ -247,6 +265,20 @@ class BraveRewardsGetAllNotificationsFunction :
   ResponseAction Run() override;
 };
 
+class BraveRewardsGetInlineTipSettingFunction :
+    public UIThreadExtensionFunction {
+ public:
+  DECLARE_EXTENSION_FUNCTION("braveRewards.getInlineTipSetting", UNKNOWN)
+
+ protected:
+  ~BraveRewardsGetInlineTipSettingFunction() override;
+
+  ResponseAction Run() override;
+
+ private:
+  void OnInlineTipSetting(bool value);
+};
+
 }  // namespace api
 }  // namespace extensions
 

browser/ui/webui/brave_rewards_ui.cc

@@ -115,6 +115,8 @@ class RewardsDOMHandler : public WebUIMessageHandler,
   void OnGetOneTimeTips(
     std::unique_ptr<brave_rewards::ContentSiteList> list);
 
+  void SetInlineTipSetting(const base::ListValue* args);
+
   // RewardsServiceObserver implementation
   void OnWalletInitialized(brave_rewards::RewardsService* rewards_service,
                        uint32_t result) override;
@@ -292,6 +294,9 @@ void RewardsDOMHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("brave_rewards.getExcludedPublishersNumber",
       base::BindRepeating(&RewardsDOMHandler::GetExcludedPublishersNumber,
       base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("brave_rewards.setInlineTipSetting",
+      base::BindRepeating(&RewardsDOMHandler::SetInlineTipSetting,
+      base::Unretained(this)));
 }
 
 void RewardsDOMHandler::Init() {
@@ -1079,6 +1084,18 @@ void RewardsDOMHandler::OnContributionSaved(
       "brave_rewards.onContributionSaved", result);
 }
 
+void RewardsDOMHandler::SetInlineTipSetting(const base::ListValue* args) {
+  std::string key;
+  args->GetString(0, &key);
+
+  std::string value;
+  args->GetString(1, &value);
+
+  if (rewards_service_) {
+    rewards_service_->SetInlineTipSetting(key, value == "true");
+  }
+}
+
 }  // namespace
 
 BraveRewardsUI::BraveRewardsUI(content::WebUI* web_ui, const std::string& name)