Remove extended attributes. The lame broken codepath in the DBS was causing

chrome/browser/sync/syncable/syncable_unittest.cc

 // Copyright (c) 2009 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/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/types.h>
 
@@ skipping 29 matching lines @@
 #include "third_party/sqlite/preprocessed/sqlite3.h"
 
 using browser_sync::TestIdFactory;
 using std::cout;
 using std::endl;
 using std::string;
 
 namespace syncable {
 
 namespace {
-// A lot of these tests were written expecting to be able to read and write
-// object data on entries.  However, the design has changed.
-void PutDataAsExtendedAttribute(WriteTransaction* wtrans,
-                                MutableEntry* e,
-                                const char* bytes,
-                                size_t bytes_length) {
-  ExtendedAttributeKey key(e->Get(META_HANDLE), "DATA");
-  MutableExtendedAttribute attr(wtrans, CREATE, key);
-  Blob bytes_blob(bytes, bytes + bytes_length);
-  attr.mutable_value()->swap(bytes_blob);
+void PutDataAsBookmarkFavicon(WriteTransaction* wtrans,
+                              MutableEntry* e,
+                              const char* bytes,
+                              size_t bytes_length) {
+  sync_pb::EntitySpecifics specifics;
+  specifics.MutableExtension(sync_pb::bookmark)->set_url("http://demo/");
+  specifics.MutableExtension(sync_pb::bookmark)->set_favicon(bytes,
+      bytes_length);
+  e->Put(SPECIFICS, specifics);
 }
 
-void ExpectDataFromExtendedAttributeEquals(BaseTransaction* trans,
-                                           Entry* e,
-                                           const char* bytes,
-                                           size_t bytes_length) {
+void ExpectDataFromBookmarkFaviconEquals(BaseTransaction* trans,
+                                         Entry* e,
+                                         const char* bytes,
+                                         size_t bytes_length) {
   ASSERT_TRUE(e->good());
-  Blob expected_value(bytes, bytes + bytes_length);
-  ExtendedAttributeKey key(e->Get(META_HANDLE), "DATA");
-  ExtendedAttribute attr(trans, GET_BY_HANDLE, key);
-  EXPECT_FALSE(attr.is_deleted());
-  EXPECT_EQ(expected_value, attr.value());
+  ASSERT_TRUE(e->Get(SPECIFICS).HasExtension(sync_pb::bookmark));
+  ASSERT_EQ("http://demo/",
+      e->Get(SPECIFICS).GetExtension(sync_pb::bookmark).url());
+  ASSERT_EQ(std::string(bytes, bytes_length),
+      e->Get(SPECIFICS).GetExtension(sync_pb::bookmark).favicon());
 }
 }  // namespace
 
 class SyncableGeneralTest : public testing::Test {
  public:
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     db_path_ = temp_dir_.path().Append(
         FILE_PATH_LITERAL("SyncableTest.sqlite3"));
   }
@@ skipping 49 matching lines @@
       EXPECT_EQ(*i, written_metahandle);
     }
   }
 
   // Test writing data to an entity. Also check that GET_BY_HANDLE works.
   static const char s[] = "Hello World.";
   {
     WriteTransaction trans(&dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry e(&trans, GET_BY_HANDLE, written_metahandle);
     ASSERT_TRUE(e.good());
-    PutDataAsExtendedAttribute(&trans, &e, s, sizeof(s));
+    PutDataAsBookmarkFavicon(&trans, &e, s, sizeof(s));
   }
 
   // Test reading back the contents that we just wrote.
   {
     WriteTransaction trans(&dir, UNITTEST, __FILE__, __LINE__);
     MutableEntry e(&trans, GET_BY_HANDLE, written_metahandle);
     ASSERT_TRUE(e.good());
-    ExpectDataFromExtendedAttributeEquals(&trans, &e, s, sizeof(s));
+    ExpectDataFromBookmarkFaviconEquals(&trans, &e, s, sizeof(s));
   }
 
   // Verify it exists in the folder.
   {
     ReadTransaction rtrans(&dir, __FILE__, __LINE__);
     EXPECT_EQ(1, CountEntriesWithName(&rtrans, rtrans.root_id(), name));
   }
 
   // Now delete it.
   {
@@ skipping 1243 matching lines @@
           file_util::Delete(directory_manager_->GetSyncDataDatabasePath(),
                             true);
           // Test.
           directory_manager_->Open(dirname);
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
           WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
           MutableEntry me(&trans, CREATE, trans.root_id(), "Jeff");
           me.Put(BASE_VERSION, 1);
           me.Put(ID, jeff_id);
-          PutDataAsExtendedAttribute(&trans, &me, test_bytes,
+          PutDataAsBookmarkFavicon(&trans, &me, test_bytes,
                                      sizeof(test_bytes));
         }
         {
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
           dir->SaveChanges();
         }
         directory_manager_->Close(dirname);
         break;
       case 1:
         {
           directory_manager_->Open(dirname);
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
         }
         break;
       case 2:
         {
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
         }
         break;
       case 3:
         {
           ScopedDirLookup dir(directory_manager_, dirname);
           CHECK(dir.good());
           ReadTransaction trans(dir, __FILE__, __LINE__);
           Entry e(&trans, GET_BY_ID, jeff_id);
-          ExpectDataFromExtendedAttributeEquals(&trans, &e, test_bytes,
+          ExpectDataFromBookmarkFaviconEquals(&trans, &e, test_bytes,
                                                 sizeof(test_bytes));
         }
         // Same result as CloseAllDirectories, but more code coverage.
         directory_manager_->Close(dirname);
         break;
       }
       step_->number += 1;
       step_->condvar.Signal();
     }
   }
@@ skipping 117 matching lines @@
     }
   }
 }
 
 void FakeSync(MutableEntry* e, const char* fake_id) {
   e->Put(IS_UNSYNCED, false);
   e->Put(BASE_VERSION, 2);
   e->Put(ID, Id::CreateFromServerId(fake_id));
 }
 
-TEST_F(SyncableDirectoryTest, Bug1509232) {
-  const string a = "alpha";
-  const Id entry_id = dir_.get()->NextId();
-  CreateEntry(a, entry_id);
-  {
-    WriteTransaction trans(dir_.get(), UNITTEST, __FILE__, __LINE__);
-    MutableEntry e(&trans, GET_BY_ID, entry_id);
-    ASSERT_TRUE(e.good());
-    ExtendedAttributeKey key(e.Get(META_HANDLE), "resourcefork");
-    MutableExtendedAttribute ext(&trans, CREATE, key);
-    ASSERT_TRUE(ext.good());
-    const char value[] = "stuff";
-    Blob value_blob(value, value + arraysize(value));
-    ext.mutable_value()->swap(value_blob);
-    ext.delete_attribute();
-  }
-  // This call to SaveChanges used to CHECK fail.
-  dir_.get()->SaveChanges();
-}
-
 class SyncableClientTagTest : public SyncableDirectoryTest {
  public:
   static const int kBaseVersion = 1;
   const char* test_name_;
   const char* test_tag_;
 
   SyncableClientTagTest() : test_name_("test_name"), test_tag_("dietcoke") {}
 
   bool CreateWithDefaultTag(Id id, bool deleted) {
     return CreateWithTag(test_tag_, id, deleted);
@@ skipping 77 matching lines @@
 TEST_F(SyncableClientTagTest, TestClientTagIndexDuplicateServer) {
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable