// 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 <stddef.h>

#include "base/guid.h"
#include "base/i18n/number_formatting.h"
#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "chrome/browser/sessions/session_service.h"
#include "chrome/browser/sync/test/integration/bookmarks_helper.h"
#include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
#include "chrome/browser/sync/test/integration/sync_test.h"
#include "chrome/browser/sync/test/integration/typed_urls_helper.h"
#include "chrome/browser/sync/test/integration/updated_progress_marker_checker.h"
#include "components/history/core/browser/history_types.h"

using base::ASCIIToUTF16;
using bookmarks::BookmarkNode;
using typed_urls_helper::AddUrlToHistory;
using typed_urls_helper::AddUrlToHistoryWithTimestamp;
using typed_urls_helper::AddUrlToHistoryWithTransition;
using typed_urls_helper::AreVisitsEqual;
using typed_urls_helper::AreVisitsUnique;
using typed_urls_helper::CheckSyncHasMetadataForURLID;
using typed_urls_helper::CheckSyncHasURLMetadata;
using typed_urls_helper::CheckURLRowVectorsAreEqualForTypedURLs;
using typed_urls_helper::DeleteUrlFromHistory;
using typed_urls_helper::ExpireHistoryBefore;
using typed_urls_helper::ExpireHistoryBetween;
using typed_urls_helper::GetTypedUrlsFromClient;
using typed_urls_helper::GetUrlFromClient;
using typed_urls_helper::GetVisitsFromClient;
using typed_urls_helper::RemoveVisitsFromClient;

namespace {
const std::string kDummyUrl = "http://dummy-history.google.com/";
}  // namespace

class TwoClientTypedUrlsSyncTest : public SyncTest {
 public:
  TwoClientTypedUrlsSyncTest() : SyncTest(TWO_CLIENT) {}
  ~TwoClientTypedUrlsSyncTest() override {}

  ::testing::AssertionResult CheckClientsEqual() {
    history::URLRows urls = GetTypedUrlsFromClient(0);
    history::URLRows urls2 = GetTypedUrlsFromClient(1);
    if (!CheckURLRowVectorsAreEqualForTypedURLs(urls, urls2))
      return ::testing::AssertionFailure() << "URLVectors are not equal";
    // Now check the visits.
    for (size_t i = 0; i < urls.size() && i < urls2.size(); i++) {
      history::VisitVector visit1 = GetVisitsFromClient(0, urls[i].id());
      history::VisitVector visit2 = GetVisitsFromClient(1, urls2[i].id());
      if (!AreVisitsEqual(visit1, visit2))
        return ::testing::AssertionFailure() << "Visits are not equal";
    }
    return ::testing::AssertionSuccess();
  }

  bool CheckNoDuplicateVisits() {
    for (int i = 0; i < num_clients(); ++i) {
      history::URLRows urls = GetTypedUrlsFromClient(i);
      for (size_t j = 0; j < urls.size(); ++j) {
        history::VisitVector visits = GetVisitsFromClient(i, urls[j].id());
        if (!AreVisitsUnique(visits))
          return false;
      }
    }
    return true;
  }

  int GetVisitCountForFirstURL(int index) {
    history::URLRows urls = GetTypedUrlsFromClient(index);
    if (urls.empty())
      return 0;
    else
      return urls[0].visit_count();
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(TwoClientTypedUrlsSyncTest);
};

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, E2E_ENABLED(Add)) {
  // Use a randomized URL to prevent test collisions.
  const base::string16 kHistoryUrl = ASCIIToUTF16(base::StringPrintf(
      "http://www.add-history.google.com/%s", base::GenerateGUID().c_str()));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  size_t initial_count = GetTypedUrlsFromClient(0).size();

  // Populate one client with a URL, wait for it to sync to the other.
  GURL new_url(kHistoryUrl);
  AddUrlToHistory(0, new_url);
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  // Assert that the second client has the correct new URL.
  history::URLRows urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(initial_count + 1, urls.size());
  ASSERT_EQ(new_url, urls.back().url());
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, AddExpired) {
  const base::string16 kHistoryUrl(
      ASCIIToUTF16("http://www.add-one-history.google.com/"));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  // Populate one client with a URL, should sync to the other.
  GURL new_url(kHistoryUrl);
  // Create a URL with a timestamp 1 year before today.
  base::Time timestamp = base::Time::Now() - base::TimeDelta::FromDays(365);
  AddUrlToHistoryWithTimestamp(0,
                               new_url,
                               ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED,
                               timestamp);
  history::URLRows urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(new_url, urls[0].url());

  // Let sync finish.
  // Add a dummy url and sync it.
  AddUrlToHistory(0, GURL(kDummyUrl));
  urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(2U, urls.size());
  ASSERT_TRUE(TypedURLChecker(1, kDummyUrl).Wait());

  // Second client should only have dummy URL since kHistoryUrl is expired.
  urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(GURL(kDummyUrl), urls.back().url());
  EXPECT_TRUE(CheckSyncHasURLMetadata(1, GURL(kDummyUrl)));

  // Sync on both clients should not receive expired visits.
  EXPECT_FALSE(CheckSyncHasURLMetadata(0, new_url));
  EXPECT_FALSE(CheckSyncHasURLMetadata(1, new_url));
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, AddExpiredThenUpdate) {
  const base::string16 kHistoryUrl(
      ASCIIToUTF16("http://www.add-one-history.google.com/"));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  // Populate one client with a URL, should sync to the other.
  GURL new_url(kHistoryUrl);
  // Create a URL with a timestamp 1 year before today.
  base::Time timestamp = base::Time::Now() - base::TimeDelta::FromDays(365);
  AddUrlToHistoryWithTimestamp(0,
                               new_url,
                               ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED,
                               timestamp);
  std::vector<history::URLRow> urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(new_url, urls[0].url());

  // Let sync finish.
  // Add a dummy url and sync it.
  AddUrlToHistory(0, GURL(kDummyUrl));
  urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(2U, urls.size());
  ASSERT_TRUE(TypedURLChecker(1, kDummyUrl).Wait());

  // Second client should only have dummy URL since kHistoryUrl is expired.
  urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(1U, urls.size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(0, GURL(kDummyUrl)));

  // Sync should not receive expired visits.
  EXPECT_FALSE(CheckSyncHasURLMetadata(0, new_url));

  // Now drive an update on the first client.
  AddUrlToHistory(0, new_url);

  // Let sync finish again.
  ASSERT_TRUE(TypedURLChecker(1, new_url.spec()).Wait());

  // Second client should have kHistoryUrl now.
  urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(2U, urls.size());

  // Sync should receive the new visit.
  EXPECT_TRUE(CheckSyncHasURLMetadata(0, new_url));
  EXPECT_TRUE(CheckSyncHasURLMetadata(1, new_url));
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest,
                       AddThenExpireOnSecondClient) {
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  base::Time now = base::Time::Now();

  // Populate one client with a URL, should sync to the other.
  GURL url("http://www.add-one-history.google.com/");
  base::Time insertion_time = now - base::TimeDelta::FromDays(1);
  AddUrlToHistoryWithTimestamp(0, url, ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED, insertion_time);
  std::vector<history::URLRow> urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(url, urls[0].url());
  history::URLID url_id_on_first_client = urls[0].id();

  // Wait for sync to finish.
  ASSERT_TRUE(TypedURLChecker(1, url.spec()).Wait());

  // Second client should have the url.
  ASSERT_EQ(1U, GetTypedUrlsFromClient(1).size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(1, url));

  // Expire the url on the second client.
  ExpireHistoryBefore(1, insertion_time + base::TimeDelta::FromSeconds(1));

  // The data and the metadata should be gone on the second client.
  ASSERT_EQ(0U, GetTypedUrlsFromClient(1).size());
  EXPECT_FALSE(CheckSyncHasURLMetadata(1, url));

  // Let sync finish; Add a dummy url to the second client and sync it.
  AddUrlToHistory(1, GURL(kDummyUrl));
  ASSERT_EQ(1U, GetTypedUrlsFromClient(1).size());
  ASSERT_TRUE(TypedURLChecker(0, kDummyUrl).Wait());

  // The expiration should not get synced up, the first client still has the
  // URL (and also the dummy URL)
  ASSERT_EQ(2U, GetTypedUrlsFromClient(0).size());
  EXPECT_TRUE(CheckSyncHasMetadataForURLID(0, url_id_on_first_client));
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, AddThenExpireThenAddAgain) {
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  base::Time now = base::Time::Now();

  // Populate one client with a URL, should sync to the other.
  GURL url("http://www.add-one-history.google.com/");
  base::Time insertion_time = now - base::TimeDelta::FromDays(1);
  AddUrlToHistoryWithTimestamp(0, url, ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED, insertion_time);
  std::vector<history::URLRow> urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(url, urls[0].url());
  history::URLID url_id_on_first_client = urls[0].id();

  // Wait for sync to finish.
  ASSERT_TRUE(TypedURLChecker(1, url.spec()).Wait());

  // Second client should have the url.
  urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(1U, urls.size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(0, url));

  // Expire the url on the first client.
  ExpireHistoryBefore(0, insertion_time + base::TimeDelta::FromSeconds(1));

  // The data and the metadata should be gone on the first client.
  ASSERT_EQ(0U, GetTypedUrlsFromClient(0).size());
  EXPECT_FALSE(CheckSyncHasMetadataForURLID(0, url_id_on_first_client));

  // Let sync finish.
  // Add a dummy url and sync it.
  AddUrlToHistory(0, GURL(kDummyUrl));
  urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_TRUE(TypedURLChecker(1, kDummyUrl).Wait());

  // The expiration should not get synced up, the second client still has the
  // URL.
  urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(2U, urls.size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(1, url));

  // The first client can add the URL again (regression test for
  // https://crbug.com/827111).
  AddUrlToHistoryWithTransition(0, url, ui::PAGE_TRANSITION_TYPED,
                                history::SOURCE_BROWSED);
  urls = GetTypedUrlsFromClient(0);
  EXPECT_EQ(2U, urls.size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(0, url));
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, AddThenExpireVisitByVisit) {
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  base::Time now = base::Time::Now();

  // Populate one client with a URL (with three visits), should sync to the
  // other. First non-typed, then typed, then non-typed again.
  GURL url("http://www.add-one-history.google.com/");
  base::Time insertion_time = now - base::TimeDelta::FromDays(6);
  base::Time second_typed_visit_time = now - base::TimeDelta::FromDays(5);
  base::Time third_link_visit_time = now - base::TimeDelta::FromDays(4);
  base::Time dummy_visit_1 = now - base::TimeDelta::FromDays(3);
  base::Time dummy_visit_2 = now - base::TimeDelta::FromDays(2);
  base::Time dummy_visit_3 = now - base::TimeDelta::FromDays(1);
  AddUrlToHistoryWithTimestamp(0, url, ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, insertion_time);
  AddUrlToHistoryWithTimestamp(0, url, ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED,
                               second_typed_visit_time);
  AddUrlToHistoryWithTimestamp(0, url, ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, third_link_visit_time);
  std::vector<history::URLRow> urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(url, urls[0].url());
  history::URLID url_id_on_first_client = urls[0].id();

  // Wait for sync to finish.
  ASSERT_TRUE(TypedURLChecker(1, url.spec()).Wait());

  // Second client should have the url.
  ASSERT_EQ(1U, GetTypedUrlsFromClient(1).size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(1, url));

  // Expire the first (non-typed) visit on the first client and assert both data
  // and metadata are intact.
  ExpireHistoryBefore(0, insertion_time + base::TimeDelta::FromSeconds(1));
  ASSERT_EQ(1U, GetTypedUrlsFromClient(0).size());
  EXPECT_TRUE(CheckSyncHasMetadataForURLID(0, url_id_on_first_client));

  // Force a sync cycle (add a dummy typed url and sync it) and check the second
  // client still has the original URL (plus the dummy one).
  AddUrlToHistoryWithTimestamp(0, GURL(kDummyUrl), ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED, dummy_visit_1);
  ASSERT_EQ(2U, GetTypedUrlsFromClient(0).size());
  ASSERT_TRUE(TypedURLChecker(1, kDummyUrl).Wait());
  ASSERT_EQ(2U, GetTypedUrlsFromClient(1).size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(1, url));

  // Expire the second (typed) visit on the first client and assert both data
  // and metadata for the URL are gone.
  ExpireHistoryBefore(
      0, second_typed_visit_time + base::TimeDelta::FromSeconds(1));
  std::vector<history::URLRow> pruned_urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, pruned_urls.size());
  ASSERT_EQ(GURL(kDummyUrl), pruned_urls[0].url());
  EXPECT_FALSE(CheckSyncHasMetadataForURLID(0, url_id_on_first_client));

  // Force a sync cycle (add another visit to the dummy url and sync it).
  AddUrlToHistoryWithTimestamp(0, GURL(kDummyUrl), ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED, dummy_visit_2);
  ASSERT_TRUE(TypedURLChecker(1, kDummyUrl).Wait());

  // The expiration should not get synced up, the second client still has the
  // URL (and also the dummy one).
  ASSERT_EQ(2U, GetTypedUrlsFromClient(1).size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(1, url));

  // Now expire also the last non-typed visit (make sure it has no impact).
  ExpireHistoryBefore(0,
                      third_link_visit_time + base::TimeDelta::FromSeconds(1));
  ASSERT_EQ(1U, GetTypedUrlsFromClient(0).size());
  EXPECT_FALSE(CheckSyncHasMetadataForURLID(0, url_id_on_first_client));

  // Force a sync cycle (add another visit to the dummy url and sync it) and
  // check the second client still has the same state.
  AddUrlToHistoryWithTimestamp(0, GURL(kDummyUrl), ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED, dummy_visit_3);
  ASSERT_TRUE(TypedURLChecker(1, kDummyUrl).Wait());
  ASSERT_EQ(2U, GetTypedUrlsFromClient(1).size());
  EXPECT_TRUE(CheckSyncHasURLMetadata(1, url));
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, E2E_ENABLED(AddThenDelete)) {
  // Use a randomized URL to prevent test collisions.
  const base::string16 kHistoryUrl = ASCIIToUTF16(base::StringPrintf(
      "http://www.add-history.google.com/%s", base::GenerateGUID().c_str()));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  size_t initial_count = GetTypedUrlsFromClient(0).size();

  // Populate one client with a URL, wait for it to sync to the other.
  GURL new_url(kHistoryUrl);
  AddUrlToHistory(0, new_url);
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  // Assert that the second client has the correct new URL.
  history::URLRows urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(initial_count + 1, urls.size());
  ASSERT_EQ(new_url, urls.back().url());

  // Delete from first client, and wait for them to sync.
  DeleteUrlFromHistory(0, new_url);
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  // Assert that it's deleted from the second client.
  ASSERT_EQ(initial_count, GetTypedUrlsFromClient(1).size());
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest,
                       AddMultipleVisitsThenDeleteAllTypedVisits) {
  const base::string16 kHistoryUrl(ASCIIToUTF16("http://history1.google.com/"));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  base::Time now = base::Time::Now();
  base::Time insertion_time = now - base::TimeDelta::FromDays(2);
  base::Time visit_time = now - base::TimeDelta::FromDays(1);

  // Populate one client with a URL with multiple visits, wait for it to sync to
  // the other.
  GURL new_url(kHistoryUrl);
  AddUrlToHistoryWithTimestamp(0, new_url, ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED, insertion_time);
  AddUrlToHistoryWithTimestamp(0, new_url, ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, visit_time);
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  // Assert that the second client has the correct new URL.
  history::URLRows urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(1u, urls.size());
  ASSERT_EQ(new_url, urls[0].url());

  // Delete the only typed visit from the first client, and wait for them to
  // sync.
  ExpireHistoryBetween(0, insertion_time - base::TimeDelta::FromSeconds(1),
                       insertion_time + base::TimeDelta::FromSeconds(1));
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  // Assert that it's deleted from the second client.
  ASSERT_EQ(0u, GetTypedUrlsFromClient(1).size());
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest,
                       E2E_ENABLED(DisableEnableSync)) {
  const base::string16 kUrl1(ASCIIToUTF16("http://history1.google.com/"));
  const base::string16 kUrl2(ASCIIToUTF16("http://history2.google.com/"));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  // Disable history sync for one client, leave it active for the other.
  GetClient(0)->DisableSyncForType(syncer::UserSelectableType::kHistory);

  // Add one URL to non-syncing client, add a different URL to the other,
  // wait for sync cycle to complete. No data should be exchanged.
  GURL url1(kUrl1);
  GURL url2(kUrl2);
  AddUrlToHistory(0, url1);
  AddUrlToHistory(1, url2);
  ASSERT_TRUE(UpdatedProgressMarkerChecker(GetSyncService(1)).Wait());

  // Make sure that no data was exchanged.
  history::URLRows post_sync_urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, post_sync_urls.size());
  ASSERT_EQ(url1, post_sync_urls[0].url());
  post_sync_urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(1U, post_sync_urls.size());
  ASSERT_EQ(url2, post_sync_urls[0].url());

  // Enable history sync, make both URLs are synced to each client.
  GetClient(0)->EnableSyncForType(syncer::UserSelectableType::kHistory);

  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, AddOneDeleteOther) {
  const base::string16 kHistoryUrl(
      ASCIIToUTF16("http://www.add-one-delete-history.google.com/"));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  // Populate one client with a URL, should sync to the other.
  GURL new_url(kHistoryUrl);
  AddUrlToHistory(0, new_url);
  history::URLRows urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(new_url, urls[0].url());

  // Both clients should have this URL.
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  // Now, delete the URL from the second client.
  DeleteUrlFromHistory(1, new_url);
  urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());

  // Both clients should have this URL removed.
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, AddOneDeleteOtherAddAgain) {
  const base::string16 kHistoryUrl(
      ASCIIToUTF16("http://www.add-delete-add-history.google.com/"));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  // Populate one client with a URL, should sync to the other.
  GURL new_url(kHistoryUrl);
  AddUrlToHistory(0, new_url);
  history::URLRows urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(new_url, urls[0].url());

  // Both clients should have this URL.
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  // Now, delete the URL from the second client.
  DeleteUrlFromHistory(1, new_url);
  urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());

  // Both clients should have this URL removed.
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  // Add it to the first client again, should succeed (tests that the deletion
  // properly disassociates that URL).
  AddUrlToHistory(0, new_url);

  // Both clients should have this URL added again.
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest,
                       MergeTypedWithNonTypedDuringAssociation) {
  ASSERT_TRUE(SetupClients());
  GURL new_url("http://history.com");
  base::Time timestamp = base::Time::Now();
  // Put a non-typed URL in both clients with an identical timestamp.
  // Then add a typed URL to the second client - this test makes sure that
  // we properly merge both sets of visits together to end up with the same
  // set of visits on both ends.
  AddUrlToHistoryWithTimestamp(0, new_url, ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, timestamp);
  AddUrlToHistoryWithTimestamp(1, new_url, ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, timestamp);
  AddUrlToHistoryWithTimestamp(1, new_url, ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED,
                               timestamp + base::TimeDelta::FromSeconds(1));

  // Now start up sync - URLs should get merged. Fully sync client 1 first,
  // before syncing client 0, so we have both of client 1's URLs in the sync DB
  // at the time that client 0 does model association.
  ASSERT_TRUE(GetClient(1)->SetupSync()) << "SetupSync() failed";
  ASSERT_TRUE(UpdatedProgressMarkerChecker(GetSyncService(1)).Wait());
  ASSERT_TRUE(GetClient(0)->SetupSync()) << "SetupSync() failed";
  ASSERT_TRUE(TypedURLChecker(1, new_url.spec()).Wait());

  ASSERT_TRUE(CheckClientsEqual());
  // At this point, we should have no duplicates (total visit count should be
  // 2). We only need to check client 0 since we already verified that both
  // clients are identical above.
  history::URLRows urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(new_url, urls[0].url());
  ASSERT_TRUE(CheckNoDuplicateVisits());
  ASSERT_EQ(2, GetVisitCountForFirstURL(0));
}

// Tests transitioning a URL from non-typed to typed when both clients
// have already seen that URL (so a merge is required).
IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest,
                       MergeTypedWithNonTypedDuringChangeProcessing) {
  ASSERT_TRUE(SetupClients());
  GURL new_url("http://history.com");
  base::Time timestamp = base::Time::Now();
  // Setup both clients with the identical typed URL visit. This means we can't
  // use the verifier in this test, because this will show up as two distinct
  // visits in the verifier.
  AddUrlToHistoryWithTimestamp(0, new_url, ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, timestamp);
  AddUrlToHistoryWithTimestamp(1, new_url, ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, timestamp);

  // Now start up sync. Neither URL should get synced as they do not look like
  // typed URLs.
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
  ASSERT_TRUE(CheckClientsEqual());
  history::URLRows urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(0U, urls.size());

  // Now, add a typed visit to the first client.
  AddUrlToHistoryWithTimestamp(0, new_url, ui::PAGE_TRANSITION_TYPED,
                               history::SOURCE_BROWSED,
                               timestamp + base::TimeDelta::FromSeconds(1));

  ASSERT_TRUE(TypedURLChecker(1, new_url.spec()).Wait());
  ASSERT_TRUE(CheckClientsEqual());
  ASSERT_TRUE(CheckNoDuplicateVisits());
  urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(2, GetVisitCountForFirstURL(0));
  ASSERT_EQ(2, GetVisitCountForFirstURL(1));
}

// Tests transitioning a URL from non-typed to typed when one of the clients
// has never seen that URL before (so no merge is necessary).
IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, UpdateToNonTypedURL) {
  const base::string16 kHistoryUrl(
      ASCIIToUTF16("http://www.add-delete-add-history.google.com/"));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  // Populate one client with a non-typed URL, should not be synced.
  GURL new_url(kHistoryUrl);
  AddUrlToHistoryWithTransition(0, new_url, ui::PAGE_TRANSITION_LINK,
                                history::SOURCE_BROWSED);
  history::URLRows urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(0U, urls.size());

  // Both clients should have 0 typed URLs.
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());
  urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(0U, urls.size());

  // Now, add a typed visit to this URL.
  AddUrlToHistory(0, new_url);

  // Let sync finish.
  ASSERT_TRUE(TypedURLChecker(1, new_url.spec()).Wait());

  // Both clients should have this URL as typed and have two visits synced up.
  ASSERT_TRUE(CheckClientsEqual());
  urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(new_url, urls[0].url());
  ASSERT_EQ(2, GetVisitCountForFirstURL(0));
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest,
                       E2E_ENABLED(DontSyncUpdatedNonTypedURLs)) {
  // Checks if a non-typed URL that has been updated (modified) doesn't get
  // synced. This is a regression test after fixing a bug where adding a
  // non-typed URL was guarded against but later modifying it was not. Since
  // "update" is "update or create if missing", non-typed URLs were being
  // created.
  const GURL kNonTypedURL("http://link.google.com/");
  const GURL kTypedURL("http://typed.google.com/");
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
  AddUrlToHistoryWithTransition(0, kNonTypedURL, ui::PAGE_TRANSITION_LINK,
                                history::SOURCE_BROWSED);
  AddUrlToHistoryWithTransition(0, kTypedURL, ui::PAGE_TRANSITION_TYPED,
                                history::SOURCE_BROWSED);

  // Modify the non-typed URL. It should not get synced.
  typed_urls_helper::SetPageTitle(0, kNonTypedURL, "Welcome to Non-Typed URL");
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  history::VisitVector visits;
  // First client has both visits.
  visits = typed_urls_helper::GetVisitsForURLFromClient(0, kNonTypedURL);
  ASSERT_EQ(1U, visits.size());
  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(visits[0].transition,
                                           ui::PAGE_TRANSITION_LINK));
  visits = typed_urls_helper::GetVisitsForURLFromClient(0, kTypedURL);
  ASSERT_EQ(1U, visits.size());
  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(visits[0].transition,
                                           ui::PAGE_TRANSITION_TYPED));
  // Second client has only the typed visit.
  visits = typed_urls_helper::GetVisitsForURLFromClient(1, kNonTypedURL);
  ASSERT_EQ(0U, visits.size());
  visits = typed_urls_helper::GetVisitsForURLFromClient(1, kTypedURL);
  ASSERT_EQ(1U, visits.size());
  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(visits[0].transition,
                                           ui::PAGE_TRANSITION_TYPED));
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest,
                       E2E_ENABLED(SyncTypedRedirects)) {
  const base::string16 kHistoryUrl(ASCIIToUTF16("http://typed.google.com/"));
  const base::string16 kRedirectedHistoryUrl(
      ASCIIToUTF16("http://www.typed.google.com/"));
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  // Simulate a typed address that gets redirected by the server to a different
  // address.
  GURL initial_url(kHistoryUrl);
  const ui::PageTransition initial_transition = ui::PageTransitionFromInt(
      ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_CHAIN_START);
  AddUrlToHistoryWithTransition(0, initial_url, initial_transition,
                                history::SOURCE_BROWSED);

  GURL redirected_url(kRedirectedHistoryUrl);
  const ui::PageTransition redirected_transition = ui::PageTransitionFromInt(
      ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_CHAIN_END |
      ui::PAGE_TRANSITION_SERVER_REDIRECT);
  // This address will have a typed_count == 0 because it's a redirection.
  // It should still be synced.
  AddUrlToHistoryWithTransition(0, redirected_url, redirected_transition,
                                history::SOURCE_BROWSED);

  // Both clients should have both URLs.
  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());

  history::VisitVector visits =
      typed_urls_helper::GetVisitsForURLFromClient(0, initial_url);
  ASSERT_EQ(1U, visits.size());
  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(visits[0].transition,
                                           ui::PAGE_TRANSITION_TYPED));
  visits = typed_urls_helper::GetVisitsForURLFromClient(0, redirected_url);
  ASSERT_EQ(1U, visits.size());
  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(visits[0].transition,
                                           ui::PAGE_TRANSITION_TYPED));

  visits = typed_urls_helper::GetVisitsForURLFromClient(1, initial_url);
  ASSERT_EQ(1U, visits.size());
  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(visits[0].transition,
                                           ui::PAGE_TRANSITION_TYPED));
  visits = typed_urls_helper::GetVisitsForURLFromClient(1, redirected_url);
  ASSERT_EQ(1U, visits.size());
  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(visits[0].transition,
                                           ui::PAGE_TRANSITION_TYPED));
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest,
                       SkipImportedVisits) {
  GURL imported_url("http://imported_url.com");
  GURL browsed_url("http://browsed_url.com");
  GURL browsed_and_imported_url("http://browsed_and_imported_url.com");
  ASSERT_TRUE(SetupClients());

  // Create 3 items in our first client - 1 imported, one browsed, one with
  // both imported and browsed entries.
  AddUrlToHistoryWithTransition(0, imported_url,
                                ui::PAGE_TRANSITION_TYPED,
                                history::SOURCE_FIREFOX_IMPORTED);
  AddUrlToHistoryWithTransition(0, browsed_url,
                                ui::PAGE_TRANSITION_TYPED,
                                history::SOURCE_BROWSED);
  AddUrlToHistoryWithTransition(0, browsed_and_imported_url,
                                ui::PAGE_TRANSITION_TYPED,
                                history::SOURCE_FIREFOX_IMPORTED);

  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
  ASSERT_TRUE(TypedURLChecker(1, browsed_url.spec()).Wait());
  history::URLRows urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(browsed_url, urls[0].url());

  // Now browse to 3rd URL - this should cause it to be synced, even though it
  // was initially imported.
  AddUrlToHistoryWithTransition(0, browsed_and_imported_url,
                                ui::PAGE_TRANSITION_TYPED,
                                history::SOURCE_BROWSED);
  ASSERT_TRUE(TypedURLChecker(1, browsed_and_imported_url.spec()).Wait());
  urls = GetTypedUrlsFromClient(1);
  ASSERT_EQ(2U, urls.size());

  // Make sure the imported URL didn't make it over.
  for (size_t i = 0; i < urls.size(); ++i) {
    ASSERT_NE(imported_url, urls[i].url());
  }
}

IN_PROC_BROWSER_TEST_F(TwoClientTypedUrlsSyncTest, BookmarksWithTypedVisit) {
  GURL bookmark_url("http://www.bookmark.google.com/");
  GURL bookmark_icon_url("http://www.bookmark.google.com/favicon.ico");
  ASSERT_TRUE(SetupClients());
  // Create a bookmark.
  const BookmarkNode* node = bookmarks_helper::AddURL(
      0, bookmarks_helper::IndexedURLTitle(0), bookmark_url);
  bookmarks_helper::SetFavicon(0, node, bookmark_icon_url,
      bookmarks_helper::CreateFavicon(SK_ColorWHITE),
      bookmarks_helper::FROM_UI);
  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";

  // A row in the DB for client 1 should have been created as a result of the
  // sync.
  history::URLRow row;
  ASSERT_TRUE(GetUrlFromClient(1, bookmark_url, &row));

  // Now, add a typed visit for client 0 to the bookmark URL and sync it over
  // - this should not cause a crash.
  AddUrlToHistory(0, bookmark_url);

  ASSERT_TRUE(ProfilesHaveSameTypedURLsChecker().Wait());
  history::URLRows urls = GetTypedUrlsFromClient(0);
  ASSERT_EQ(1U, urls.size());
  ASSERT_EQ(bookmark_url, urls[0].url());
  ASSERT_EQ(1, GetVisitCountForFirstURL(0));
}