| // Copyright 2016 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/webshare/share_service_impl.h" |
| |
| #include <algorithm> |
| #include <functional> |
| #include <utility> |
| |
| #include "base/strings/string_util.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "chrome/browser/engagement/site_engagement_service.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/ui/browser_commands.h" |
| #include "chrome/browser/ui/browser_dialogs.h" |
| #include "chrome/browser/ui/browser_list.h" |
| #include "chrome/browser/ui/browser_tabstrip.h" |
| #include "chrome/browser/ui/tabs/tab_strip_model.h" |
| #include "chrome/common/pref_names.h" |
| #include "components/prefs/pref_service.h" |
| #include "mojo/public/cpp/bindings/strong_binding.h" |
| #include "net/base/escape.h" |
| |
| namespace { |
| |
| // Determines whether a character is allowed in a URL template placeholder. |
| bool IsIdentifier(char c) { |
| return base::IsAsciiAlpha(c) || base::IsAsciiDigit(c) || c == '-' || c == '_'; |
| } |
| |
| // Joins a std::vector<base::StringPiece> into a single std::string. |
| // TODO(constantina): Implement a base::JoinString() that takes StringPieces. |
| // i.e. move this to base/strings/string_util.h, and thoroughly test. |
| std::string JoinString(const std::vector<base::StringPiece>& pieces) { |
| size_t total_size = 0; |
| for (const auto& piece : pieces) { |
| total_size += piece.size(); |
| } |
| std::string joined_pieces; |
| joined_pieces.reserve(total_size); |
| |
| for (const auto& piece : pieces) { |
| piece.AppendToString(&joined_pieces); |
| } |
| return joined_pieces; |
| } |
| |
| } // namespace |
| |
| ShareServiceImpl::ShareServiceImpl() = default; |
| ShareServiceImpl::~ShareServiceImpl() = default; |
| |
| // static |
| void ShareServiceImpl::Create(blink::mojom::ShareServiceRequest request) { |
| mojo::MakeStrongBinding(base::MakeUnique<ShareServiceImpl>(), |
| std::move(request)); |
| } |
| |
| // static |
| bool ShareServiceImpl::ReplacePlaceholders(base::StringPiece url_template, |
| base::StringPiece title, |
| base::StringPiece text, |
| const GURL& share_url, |
| std::string* url_template_filled) { |
| constexpr char kTitlePlaceholder[] = "title"; |
| constexpr char kTextPlaceholder[] = "text"; |
| constexpr char kUrlPlaceholder[] = "url"; |
| |
| std::map<base::StringPiece, std::string> placeholder_to_data; |
| placeholder_to_data[kTitlePlaceholder] = |
| net::EscapeQueryParamValue(title, false); |
| placeholder_to_data[kTextPlaceholder] = |
| net::EscapeQueryParamValue(text, false); |
| placeholder_to_data[kUrlPlaceholder] = |
| net::EscapeQueryParamValue(share_url.spec(), false); |
| |
| std::vector<base::StringPiece> split_template; |
| bool last_saw_open = false; |
| size_t start_index_to_copy = 0; |
| for (size_t i = 0; i < url_template.size(); ++i) { |
| if (last_saw_open) { |
| if (url_template[i] == '}') { |
| base::StringPiece placeholder = url_template.substr( |
| start_index_to_copy + 1, i - 1 - start_index_to_copy); |
| auto it = placeholder_to_data.find(placeholder); |
| if (it != placeholder_to_data.end()) { |
| // Replace the placeholder text with the parameter value. |
| split_template.push_back(it->second); |
| } |
| |
| last_saw_open = false; |
| start_index_to_copy = i + 1; |
| } else if (!IsIdentifier(url_template[i])) { |
| // Error: Non-identifier character seen after open. |
| return false; |
| } |
| } else { |
| if (url_template[i] == '}') { |
| // Error: Saw close, with no corresponding open. |
| return false; |
| } else if (url_template[i] == '{') { |
| split_template.push_back( |
| url_template.substr(start_index_to_copy, i - start_index_to_copy)); |
| |
| last_saw_open = true; |
| start_index_to_copy = i; |
| } |
| } |
| } |
| if (last_saw_open) { |
| // Error: Saw open that was never closed. |
| return false; |
| } |
| split_template.push_back(url_template.substr( |
| start_index_to_copy, url_template.size() - start_index_to_copy)); |
| |
| *url_template_filled = JoinString(split_template); |
| return true; |
| } |
| |
| void ShareServiceImpl::ShowPickerDialog( |
| const std::vector<std::pair<base::string16, GURL>>& targets, |
| const base::Callback<void(base::Optional<std::string>)>& callback) { |
| // TODO(mgiuca): Get the browser window as |parent_window|. |
| chrome::ShowWebShareTargetPickerDialog(nullptr /* parent_window */, targets, |
| callback); |
| } |
| |
| Browser* ShareServiceImpl::GetBrowser() { |
| return BrowserList::GetInstance()->GetLastActive(); |
| } |
| |
| void ShareServiceImpl::OpenTargetURL(const GURL& target_url) { |
| Browser* browser = GetBrowser(); |
| chrome::AddTabAt(browser, target_url, |
| browser->tab_strip_model()->active_index() + 1, true); |
| } |
| |
| std::string ShareServiceImpl::GetTargetTemplate( |
| const std::string& target_url, |
| const base::DictionaryValue& share_targets) { |
| const base::DictionaryValue* share_target_info_dict = nullptr; |
| share_targets.GetDictionaryWithoutPathExpansion(target_url, |
| &share_target_info_dict); |
| |
| std::string url_template; |
| share_target_info_dict->GetString("url_template", &url_template); |
| return url_template; |
| } |
| |
| PrefService* ShareServiceImpl::GetPrefService() { |
| return GetBrowser()->profile()->GetPrefs(); |
| } |
| |
| blink::mojom::EngagementLevel ShareServiceImpl::GetEngagementLevel( |
| const GURL& url) { |
| SiteEngagementService* site_engagement_service = |
| SiteEngagementService::Get(GetBrowser()->profile()); |
| return site_engagement_service->GetEngagementLevel(url); |
| } |
| |
| // static |
| std::vector<std::pair<base::string16, GURL>> |
| ShareServiceImpl::GetTargetsWithSufficientEngagement( |
| const base::DictionaryValue& share_targets) { |
| constexpr blink::mojom::EngagementLevel kMinimumEngagementLevel = |
| blink::mojom::EngagementLevel::LOW; |
| |
| std::vector<std::pair<base::string16, GURL>> sufficiently_engaged_targets; |
| |
| for (base::DictionaryValue::Iterator it(share_targets); !it.IsAtEnd(); |
| it.Advance()) { |
| GURL manifest_url(it.key()); |
| if (GetEngagementLevel(manifest_url) >= kMinimumEngagementLevel) { |
| const base::DictionaryValue* share_target_dict; |
| bool result = it.value().GetAsDictionary(&share_target_dict); |
| DCHECK(result); |
| |
| std::string name; |
| share_target_dict->GetString("name", &name); |
| |
| sufficiently_engaged_targets.push_back( |
| make_pair(base::UTF8ToUTF16(name), manifest_url)); |
| } |
| } |
| |
| return sufficiently_engaged_targets; |
| } |
| |
| void ShareServiceImpl::Share(const std::string& title, |
| const std::string& text, |
| const GURL& share_url, |
| const ShareCallback& callback) { |
| std::unique_ptr<base::DictionaryValue> share_targets; |
| |
| share_targets = GetPrefService() |
| ->GetDictionary(prefs::kWebShareVisitedTargets) |
| ->CreateDeepCopy(); |
| |
| std::vector<std::pair<base::string16, GURL>> sufficiently_engaged_targets = |
| GetTargetsWithSufficientEngagement(*share_targets); |
| |
| ShowPickerDialog( |
| sufficiently_engaged_targets, |
| base::Bind(&ShareServiceImpl::OnPickerClosed, base::Unretained(this), |
| base::Passed(&share_targets), title, text, share_url, |
| callback)); |
| } |
| |
| void ShareServiceImpl::OnPickerClosed( |
| std::unique_ptr<base::DictionaryValue> share_targets, |
| const std::string& title, |
| const std::string& text, |
| const GURL& share_url, |
| const ShareCallback& callback, |
| base::Optional<std::string> result) { |
| if (!result.has_value()) { |
| callback.Run(base::Optional<std::string>("Share was cancelled")); |
| return; |
| } |
| |
| std::string chosen_target = result.value(); |
| |
| std::string url_template = GetTargetTemplate(chosen_target, *share_targets); |
| std::string url_template_filled; |
| if (!ReplacePlaceholders(url_template, title, text, share_url, |
| &url_template_filled)) { |
| callback.Run(base::Optional<std::string>( |
| "Error: unable to replace placeholders in url template")); |
| return; |
| } |
| |
| // The template is relative to the manifest URL (minus the filename). |
| // Concatenate to make an absolute URL. |
| base::StringPiece url_base( |
| chosen_target.data(), |
| chosen_target.size() - GURL(chosen_target).ExtractFileName().size()); |
| const GURL target(url_base.as_string() + url_template_filled); |
| if (!target.is_valid()) { |
| callback.Run(base::Optional<std::string>( |
| "Error: url of share target is not a valid url.")); |
| return; |
| } |
| OpenTargetURL(target); |
| |
| callback.Run(base::nullopt); |
| } |