Add Generic Implementation of ClipboardRecentContent

components/open_from_clipboard/clipboard_recent_content_generic.cc

+// Copyright 2017 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 "components/open_from_clipboard/clipboard_recent_content_generic.h"
+
+#include "base/strings/string_util.h"
+#include "ui/base/clipboard/clipboard.h"
+
+ClipboardRecentContentGeneric::ClipboardRecentContentGeneric() {}
+
+bool ClipboardRecentContentGeneric::GetRecentURLFromClipboard(GURL* url) {
+  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  base::Time last_modified_time = clipboard->GetClipboardLastModifiedTime();

[dcheng, 2017/04/02 05:04:03]

Btw, I'm wondering if we should have made this return a TimeTicks. I wonder if
this might interact strangely across DST changes. I guess there's also a
question of how to handle a sleeping device (where the behavior of TimeTicks is
implementation defined, and may or may not actually advance)

Edit: I guess we try to handle this on line 54, but I'm curious if we should be
using TimeTicks here anyway.

[Mark P, 2017/04/02 05:33:56]

I consciously didn't use TimeTicks.  It makes a lot of different when the user
put something in his clipboard, put the phone away for two weeks, then reopened
it and saw a suggestion from the clipboard because the timeticks was suspended
for that time.  That's not okay.  We need to use user-visible clock time to
reflect whether this URL was recently on the user's mind recently, i.e., real
time.

[Peter Kasting, 2017/04/03 01:42:13]

Are you sure TimeTicks won't advance when the phone has the screen off?

I thought TimeTicks basically followed wall-clock time advancement, but
increased monotonically and started counting on Chrome startup.  In which case
it should still advance here.

[Mark P, 2017/04/03 03:54:37]

We also save the time (and last clipboard value) in prefs so we can estimate
when Chrome loads how old the clipboard is.  (If the clipboard info stored in
prefs is the same as the current clipboard, the time is still valid.)  For this
to work, we need a wall time, not a time that's only valid on a particular run
of Chrome.

+  if (!last_modified_time_to_suppress_.is_null() &&
+      (last_modified_time == last_modified_time_to_suppress_))
+    return false;
+
+  if (GetClipboardContentAge() > kMaximumAgeOfClipboard)
+    return false;
+
+  // Get and clean up the clipboard before processing.
+  std::string gurl_string;
+  clipboard->ReadAsciiText(ui::CLIPBOARD_TYPE_COPY_PASTE, &gurl_string);
+  base::TrimWhitespaceASCII(gurl_string, base::TrimPositions::TRIM_ALL,
+                            &gurl_string);
+
+  // Interpret the clipboard as a URL if possible.
+  DCHECK(url);
+  // If there is mid-string whitespace, don't attempt to interpret the string
+  // as a URL.  (Otherwise gurl will happily try to convert
+  // "http://example.com extra words" into "http://example.com%20extra%20words",
+  // which is not likely to be a useful or intended destination.)
+  if (gurl_string.find_first_of(base::kWhitespaceASCII) != std::string::npos)
+    return false;
+  if (!gurl_string.empty()) {
+    *url = GURL(gurl_string);
+  } else {
+    // Fall back to unicode / UTF16, as some URLs may use international domain
+    // names, not punycode.
+    base::string16 gurl_string16;
+    clipboard->ReadText(ui::CLIPBOARD_TYPE_COPY_PASTE, &gurl_string16);
+    base::TrimWhitespace(gurl_string16, base::TrimPositions::TRIM_ALL,
+                         &gurl_string16);
+    if (gurl_string16.find_first_of(base::kWhitespaceUTF16) !=
+        std::string::npos)
+      return false;
+    if (!gurl_string16.empty())
+      *url = GURL(gurl_string16);
+  }
+  return url->is_valid() && IsAppropriateSuggestion(*url);
+}
+
+base::TimeDelta ClipboardRecentContentGeneric::GetClipboardContentAge() const {
+  const base::Time last_modified_time =
+      ui::Clipboard::GetForCurrentThread()->GetClipboardLastModifiedTime();
+  const base::Time now = base::Time::Now();
+  // In case of system clock change, assume the last modified time is now.
+  // (Don't return a negative age, i.e., a time in the future.)
+  if (last_modified_time > now)
+    return base::TimeDelta();
+  return now - last_modified_time;
+}
+
+void ClipboardRecentContentGeneric::SuppressClipboardContent() {
+  // User cleared the user data.  The pasteboard entry must be removed from the
+  // omnibox list.  Do this by suppressing all clipboard content with the
+  // current clipboard content's time.  Then we only suggest the clipboard
+  // content later if the time changed.
+  last_modified_time_to_suppress_ =
+      ui::Clipboard::GetForCurrentThread()->GetClipboardLastModifiedTime();
+}